evolcore 0.0.1 → 0.0.3

package/dist/utils/restart-safety.js

@@ -0,0 +1,31 @@
+const REAL_RESTART_TEST_OVERRIDE = 'EVOLCORE_ALLOW_REAL_RESTART_IN_TEST';
+export function isRestartTestRuntime(env = process.env) {
+    return env.VITEST === 'true'
+        || env.EVOLCORE_TEST === '1';
+}
+/**
+ * Unit tests must never detach a real restart-monitor/daemon pair by accident.
+ * Dedicated process-level integration tests can opt in explicitly.
+ */
+export function shouldSuppressRealRestart(env = process.env) {
+    return isRestartTestRuntime(env) && env[REAL_RESTART_TEST_OVERRIDE] !== '1';
+}
+export function runtimeHomeFromEnv(env) {
+    return env.EVOLCORE_HOME || null;
+}
+/**
+ * Strict classifier used before automatically killing leaked test daemons.
+ * All markers must agree so a legitimate secondary runtime is never mistaken
+ * for a disposable test process.
+ */
+export function isConfirmedLeakedTestDaemon(env) {
+    const home = runtimeHomeFromEnv(env);
+    if (!home || !/[\\/]evolcore-test-[^\\/]+$/.test(home))
+        return false;
+    const launchedBy = env.EVOLCORE_LAUNCHED_BY;
+    const testRuntime = env.VITEST === 'true'
+        || env.EVOLCORE_TEST === '1';
+    return testRuntime
+        && env.NODE_ENV === 'test'
+        && launchedBy === 'restart-monitor';
+}

package/dist/utils/stats.js

@@ -0,0 +1,410 @@
+export class StatsCollector {
+    events = [];
+    recentErrors = [];
+    MAX_RECENT_ERRORS = 50;
+    startTime;
+    HOUR_MS = 3_600_000;
+    constructor(eventBus) {
+        this.startTime = Date.now();
+        // 订阅相关事件
+        eventBus.subscribe('message:received', (event) => {
+            const e = event;
+            this.recordEvent({ type: 'received', timestamp: e.timestamp || Date.now(), agentName: e.agentName });
+        });
+        eventBus.subscribe('message:sent', (event) => {
+            const e = event;
+            this.recordEvent({ type: 'sent', timestamp: e.timestamp || Date.now(), agentName: e.agentName });
+        });
+        eventBus.subscribe('task:completed', (event) => {
+            const e = event;
+            this.recordEvent({ type: 'completed', timestamp: e.timestamp || Date.now(), durationMs: e.durationMs, agentName: e.agentName });
+        });
+        eventBus.subscribe('task:error', (event) => {
+            const e = event;
+            const ts = Date.now();
+            this.recordEvent({ type: 'error', timestamp: ts, errorType: e.errorType, agentName: e.agentName });
+            this.recordRecentError({
+                ts, kind: 'task', agentName: e.agentName, errorType: e.errorType,
+                message: this.truncate(e.error),
+            });
+        });
+        eventBus.subscribe('task:interrupted', (event) => {
+            const e = event;
+            this.recordEvent({ type: 'interrupted', timestamp: Date.now(), agentName: e.agentName });
+        });
+        eventBus.subscribe('tool:result', (event) => {
+            const e = event;
+            if (e.isError) {
+                const ts = Date.now();
+                this.recordEvent({ type: 'tool-error', timestamp: ts, toolName: e.toolName, agentName: e.agentName });
+                this.recordRecentError({
+                    ts, kind: 'tool', agentName: e.agentName, toolName: e.toolName,
+                });
+            }
+        });
+    }
+    truncate(s) {
+        if (!s)
+            return undefined;
+        const oneLine = String(s).replace(/\s+/g, ' ').trim();
+        return oneLine.length > 200 ? oneLine.slice(0, 200) + '…' : oneLine;
+    }
+    recordRecentError(err) {
+        this.recentErrors.unshift(err); // 新在前
+        if (this.recentErrors.length > this.MAX_RECENT_ERRORS) {
+            this.recentErrors.length = this.MAX_RECENT_ERRORS;
+        }
+    }
+    recordEvent(record) {
+        this.events.push(record);
+    }
+    /**
+     * 获取统计快照。可选 agentName 过滤：未传则全局；传入则只统计该 agent。
+     * 自动裁剪 >1h 的事件。
+     */
+    getSnapshot(agentName) {
+        const now = Date.now();
+        const cutoff = now - this.HOUR_MS;
+        // 裁剪过期事件
+        this.events = this.events.filter(e => e.timestamp >= cutoff);
+        // 聚合统计（可按 agent 过滤）
+        const filtered = agentName === undefined
+            ? this.events
+            : this.events.filter(e => (e.agentName ?? '<unknown>') === agentName);
+        let received = 0;
+        let sent = 0;
+        let completed = 0;
+        let errors = 0;
+        const errorsByType = {};
+        let toolErrors = 0;
+        const toolErrorsByName = {};
+        let interrupts = 0;
+        let totalDuration = 0;
+        let durationCount = 0;
+        for (const event of filtered) {
+            switch (event.type) {
+                case 'received':
+                    received++;
+                    break;
+                case 'sent':
+                    sent++;
+                    break;
+                case 'completed':
+                    completed++;
+                    if (event.durationMs !== undefined) {
+                        totalDuration += event.durationMs;
+                        durationCount++;
+                    }
+                    break;
+                case 'error':
+                    errors++;
+                    if (event.errorType) {
+                        errorsByType[event.errorType] = (errorsByType[event.errorType] || 0) + 1;
+                    }
+                    break;
+                case 'tool-error':
+                    toolErrors++;
+                    if (event.toolName) {
+                        toolErrorsByName[event.toolName] = (toolErrorsByName[event.toolName] || 0) + 1;
+                    }
+                    break;
+                case 'interrupted':
+                    interrupts++;
+                    break;
+            }
+        }
+        // 最近错误：按 agent 过滤（与上面一致），取前 20 条
+        const recentErrors = (agentName === undefined
+            ? this.recentErrors
+            : this.recentErrors.filter(e => (e.agentName ?? '<unknown>') === agentName)).slice(0, 20);
+        return {
+            uptimeMs: now - this.startTime,
+            lastHour: {
+                received,
+                sent,
+                completed,
+                errors,
+                errorsByType,
+                toolErrors,
+                toolErrorsByName,
+                interrupts,
+                avgResponseMs: durationCount > 0 ? totalDuration / durationCount : 0
+            },
+            recentErrors,
+        };
+    }
+}
+export class AidStatsCollector {
+    entries = new Map();
+    queueStatsProvider;
+    /** sessionId → 当前正在跑该 session 的 agent，task:started 写入，task:completed/error 清除 */
+    sessionToAgent = new Map();
+    /** 外部注入的持久化回调（写入 message_events 表） */
+    onMessage;
+    constructor(eventBus) {
+        if (!eventBus)
+            return;
+        eventBus.subscribe('task:started', (event) => {
+            const e = event;
+            if (e.agentName)
+                this.onTaskStart(e.agentName, e.encrypt, e.chatmode);
+            if (e.agentName && e.sessionId)
+                this.sessionToAgent.set(e.sessionId, e.agentName);
+        });
+        eventBus.subscribe('task:completed', (event) => {
+            const e = event;
+            if (e.agentName)
+                this.onTaskEnd(e.agentName, 'completed', undefined, e.finalText, e.numTurns);
+            if (e.sessionId)
+                this.sessionToAgent.delete(e.sessionId);
+        });
+        eventBus.subscribe('task:error', (event) => {
+            const e = event;
+            if (e.agentName)
+                this.onTaskEnd(e.agentName, 'error', e.errorType);
+            if (e.sessionId)
+                this.sessionToAgent.delete(e.sessionId);
+        });
+        // 用户主动打断（新消息/​/stop/​撤回）：任务有自己的生命周期收尾，不计为 error
+        eventBus.subscribe('task:interrupted', (event) => {
+            const e = event;
+            if (e.agentName)
+                this.onTaskEnd(e.agentName, 'interrupted');
+            if (e.sessionId)
+                this.sessionToAgent.delete(e.sessionId);
+        });
+        // thought.put 次数 + 最后一次 thought 文本
+        // 注意：thought.put 是 fire-and-forget async，可能在 task:completed 之后才到达，
+        // 所以同时累加到 currentTask（task 进行中）或 lastTaskEnd（task 已结束但 thought 属于它）
+        eventBus.subscribe('message:thought-put', (event) => {
+            const e = event;
+            if (!e.agentName)
+                return;
+            const entry = this.entries.get(e.agentName);
+            if (!entry)
+                return;
+            if (entry.currentTaskStartAt != null) {
+                // task 进行中
+                entry.currentTaskThoughtPutCount++;
+                if (e.text)
+                    entry.currentTaskLastThoughtText = e.text;
+            }
+            else if (entry.lastTaskEnd) {
+                // task 已结束，回填到最近一次 task
+                entry.lastTaskEnd.thoughtPutCount++;
+                entry.lastTaskEnd.thoughtDuringTask = true;
+                if (e.text) {
+                    const t = e.text.length > 100 ? e.text.slice(0, 100) + '…' : e.text;
+                    entry.lastTaskEnd.lastThoughtText = t;
+                }
+            }
+        });
+        // 工具调用次数（tool:use 事件）
+        eventBus.subscribe('tool:use', (event) => {
+            const e = event;
+            if (!e.sessionId)
+                return;
+            const agent = this.sessionToAgent.get(e.sessionId);
+            if (!agent)
+                return;
+            const entry = this.entries.get(agent);
+            if (entry && entry.currentTaskStartAt != null)
+                entry.currentTaskToolUseCount++;
+        });
+    }
+    setQueueStatsProvider(provider) {
+        this.queueStatsProvider = provider;
+    }
+    getOrCreate(aid) {
+        let entry = this.entries.get(aid);
+        if (!entry) {
+            entry = {
+                aid,
+                selfName: null,
+                messagesReceived: 0,
+                messagesSent: 0,
+                systemReceived: 0,
+                systemSent: 0,
+                bytesReceived: 0,
+                bytesSent: 0,
+                lastReceivedAt: null,
+                lastSentAt: null,
+                lastReceivedText: null,
+                lastReceivedFrom: null,
+                lastReceivedEncrypt: null,
+                lastReceivedChatmode: null,
+                lastSentText: null,
+                lastSentTo: null,
+                lastSentEncrypt: null,
+                lastSentChatmode: null,
+                lastReceivedKind: null,
+                lastSentKind: null,
+                uniquePeers: new Set(),
+                recentMessages: [],
+                currentTaskStartAt: null,
+                currentTaskReplyCount: 0,
+                currentTaskThoughtPutCount: 0,
+                currentTaskToolUseCount: 0,
+                currentTaskNumTurns: 0,
+                currentTaskLastThoughtText: null,
+                currentTaskSessionId: null,
+                currentTaskChatmode: null,
+                currentTaskEncrypt: null,
+                lastTaskEnd: undefined,
+            };
+            this.entries.set(aid, entry);
+        }
+        return entry;
+    }
+    onTaskStart(aid, encrypt, chatmode) {
+        const entry = this.getOrCreate(aid);
+        entry.currentTaskStartAt = Date.now();
+        entry.currentTaskReplyCount = 0;
+        entry.currentTaskThoughtPutCount = 0;
+        entry.currentTaskToolUseCount = 0;
+        entry.currentTaskNumTurns = 0;
+        entry.currentTaskLastThoughtText = null;
+        entry.currentTaskChatmode = chatmode ?? null;
+        entry.currentTaskEncrypt = encrypt ?? null;
+    }
+    onTaskEnd(aid, status, errorType, finalText, numTurns) {
+        const entry = this.getOrCreate(aid);
+        const taskEndTs = Date.now();
+        // 先用内存计数写入初始值（立即可用）
+        const buildTaskEnd = (msgCount, thoughtCount, lastThought) => ({
+            ts: taskEndTs,
+            status,
+            errorType,
+            sentDuringTask: msgCount > 0,
+            thoughtDuringTask: thoughtCount > 0,
+            lastThoughtText: lastThought,
+            replyCount: msgCount,
+            thoughtPutCount: thoughtCount,
+            toolUseCount: entry.currentTaskToolUseCount,
+            numTurns: numTurns ?? entry.currentTaskNumTurns,
+            finalText: finalText ? (finalText.length > 100 ? finalText.slice(0, 100) + '…' : finalText) : undefined,
+            chatmode: entry.currentTaskChatmode ?? undefined,
+            encrypt: entry.currentTaskEncrypt ?? undefined,
+        });
+        entry.lastTaskEnd = buildTaskEnd(entry.currentTaskReplyCount, entry.currentTaskThoughtPutCount, entry.currentTaskLastThoughtText ?? undefined);
+        entry.currentTaskStartAt = null;
+        entry.currentTaskReplyCount = 0;
+        entry.currentTaskThoughtPutCount = 0;
+        entry.currentTaskToolUseCount = 0;
+        entry.currentTaskNumTurns = 0;
+        entry.currentTaskLastThoughtText = null;
+    }
+    setSelfName(aid, name) {
+        const entry = this.getOrCreate(aid);
+        entry.selfName = name;
+    }
+    recordInbound(aid, fromPeer, byteLength, text, isSystem = false, encrypt, chatmode, kind = 'send') {
+        const entry = this.getOrCreate(aid);
+        if (isSystem) {
+            entry.systemReceived++;
+        }
+        else {
+            entry.messagesReceived++;
+            entry.lastReceivedAt = Date.now();
+            entry.lastReceivedFrom = fromPeer;
+            if (text)
+                entry.lastReceivedText = text.length > 100 ? text.slice(0, 100) + '…' : text;
+            if (encrypt != null)
+                entry.lastReceivedEncrypt = encrypt;
+            if (chatmode)
+                entry.lastReceivedChatmode = chatmode;
+            entry.lastReceivedKind = kind;
+            // ring buffer：最近 10 轮
+            if (text) {
+                entry.recentMessages.unshift({ dir: 'in', peer: fromPeer, text: text.slice(0, 100), ts: Date.now(), kind, encrypt: encrypt ?? null, chatmode: chatmode ?? null });
+                if (entry.recentMessages.length > 10)
+                    entry.recentMessages.pop();
+            }
+        }
+        entry.bytesReceived += byteLength;
+        entry.uniquePeers.add(fromPeer);
+        // 持久化
+        this.onMessage?.({
+            ts: Date.now(), agent_aid: aid, peer_key: `aun#${fromPeer}`,
+            direction: 'in', msg_type: isSystem ? 'system' : 'private',
+            bytes: byteLength, encrypted: encrypt, chatmode,
+        });
+    }
+    recordOutbound(aid, toPeer, byteLength, text, isSystem = false, encrypt, chatmode, kind = 'send') {
+        const entry = this.getOrCreate(aid);
+        if (isSystem) {
+            entry.systemSent++;
+        }
+        else {
+            entry.messagesSent++;
+            entry.lastSentAt = Date.now();
+            entry.lastSentTo = toPeer;
+            if (text)
+                entry.lastSentText = text.length > 100 ? text.slice(0, 100) + '…' : text;
+            if (encrypt != null)
+                entry.lastSentEncrypt = encrypt;
+            if (chatmode)
+                entry.lastSentChatmode = chatmode;
+            entry.lastSentKind = kind;
+            // ring buffer：最近 10 轮
+            if (text) {
+                entry.recentMessages.unshift({ dir: 'out', peer: toPeer, text: text.slice(0, 100), ts: Date.now(), kind, encrypt: encrypt ?? null, chatmode: chatmode ?? null });
+                if (entry.recentMessages.length > 10)
+                    entry.recentMessages.pop();
+            }
+            // 累计当前 task 的回复数
+            if (entry.currentTaskStartAt != null) {
+                entry.currentTaskReplyCount++;
+                if (chatmode)
+                    entry.currentTaskChatmode = chatmode;
+                if (encrypt != null)
+                    entry.currentTaskEncrypt = encrypt;
+            }
+        }
+        entry.bytesSent += byteLength;
+        entry.uniquePeers.add(toPeer);
+        // 持久化
+        this.onMessage?.({
+            ts: Date.now(), agent_aid: aid, peer_key: `aun#${toPeer}`,
+            direction: 'out', msg_type: isSystem ? 'system' : 'private',
+            bytes: byteLength, encrypted: encrypt, chatmode,
+        });
+    }
+    getAllSnapshots() {
+        const out = [];
+        for (const entry of this.entries.values()) {
+            const queueStats = this.queueStatsProvider
+                ? this.queueStatsProvider(entry.aid)
+                : { processing: 0, queued: 0, muted: false };
+            out.push({
+                aid: entry.aid,
+                selfName: entry.selfName,
+                messagesReceived: entry.messagesReceived,
+                messagesSent: entry.messagesSent,
+                systemReceived: entry.systemReceived,
+                systemSent: entry.systemSent,
+                bytesReceived: entry.bytesReceived,
+                bytesSent: entry.bytesSent,
+                lastReceivedAt: entry.lastReceivedAt,
+                lastSentAt: entry.lastSentAt,
+                lastReceivedText: entry.lastReceivedText,
+                lastReceivedFrom: entry.lastReceivedFrom,
+                lastReceivedEncrypt: entry.lastReceivedEncrypt,
+                lastReceivedChatmode: entry.lastReceivedChatmode,
+                lastSentText: entry.lastSentText,
+                lastSentTo: entry.lastSentTo,
+                lastSentEncrypt: entry.lastSentEncrypt,
+                lastSentChatmode: entry.lastSentChatmode,
+                lastReceivedKind: entry.lastReceivedKind,
+                lastSentKind: entry.lastSentKind,
+                uniquePeerCount: entry.uniquePeers.size,
+                processing: queueStats.processing,
+                queued: queueStats.queued,
+                muted: queueStats.muted,
+                recentMessages: entry.recentMessages,
+                lastTaskEnd: entry.lastTaskEnd,
+            });
+        }
+        return out;
+    }
+}

package/dist/utils/system-memory.js

@@ -0,0 +1,62 @@
+import fs from 'fs';
+import os from 'os';
+function readNumber(filePath) {
+    try {
+        const value = Number(fs.readFileSync(filePath, 'utf8').trim());
+        return Number.isFinite(value) && value >= 0 ? value : null;
+    }
+    catch {
+        return null;
+    }
+}
+export function parseCgroupV2MemoryStat(input) {
+    const values = new Map();
+    for (const line of input.split('\n')) {
+        const [key, raw] = line.trim().split(/\s+/, 2);
+        const value = Number(raw);
+        if (key && Number.isFinite(value) && value >= 0)
+            values.set(key, value);
+    }
+    return values;
+}
+/**
+ * System memory for the current container/host namespace.
+ *
+ * Linux cgroup v2 uses memory.current - memory.stat:file so the value matches
+ * common host/container dashboards: anonymous + kernel memory, excluding
+ * reclaimable filesystem page cache. Other environments fall back to the
+ * portable total - available calculation exposed by Node.js.
+ */
+export function readSystemMemoryUsage(cgroupRoot = '/sys/fs/cgroup') {
+    const memTotal = os.totalmem();
+    const memAvailable = os.freemem();
+    if (process.platform === 'linux') {
+        const current = readNumber(`${cgroupRoot}/memory.current`);
+        if (current !== null) {
+            try {
+                const stat = parseCgroupV2MemoryStat(fs.readFileSync(`${cgroupRoot}/memory.stat`, 'utf8'));
+                const fileCache = stat.get('file');
+                if (fileCache !== undefined) {
+                    const memUsed = Math.max(0, current - fileCache);
+                    return {
+                        memTotal,
+                        memUsed,
+                        memFree: Math.max(0, memTotal - memUsed),
+                        memAvailable,
+                        memorySource: 'cgroup-v2-current-minus-file',
+                        cgroupCurrent: current,
+                        fileCache,
+                    };
+                }
+            }
+            catch { /* fall through to portable OS metrics */ }
+        }
+    }
+    return {
+        memTotal,
+        memUsed: Math.max(0, memTotal - memAvailable),
+        memFree: memAvailable,
+        memAvailable,
+        memorySource: 'os-total-minus-available',
+    };
+}