evolclaw 2.8.3 → 3.1.0

package/dist/utils/logger.js

@@ -1,85 +1,34 @@
-import fs from 'fs';
-import path from 'path';
 import { resolvePaths } from '../paths.js';
+import { LogWriter } from './log-writer.js';
 const LOG_DIR = resolvePaths().logs;
 let currentLevel = process.env.LOG_LEVEL || 'INFO';
 const LEVELS = { DEBUG: 0, INFO: 1, WARN: 2, ERROR: 3 };
-const HOUR_MS = 60 * 60 * 1000;
-const RETAIN_HOURS = 12;
-const LOG_FILE_RE = /^evolclaw-\d{8}-\d{2}\.log$/;
 const config = {
     messageLog: process.env.MESSAGE_LOG === 'true',
     eventLog: process.env.EVENT_LOG === 'true'
 };
-if (!fs.existsSync(LOG_DIR)) {
-    fs.mkdirSync(LOG_DIR, { recursive: true });
-}
-/** 获取当前小时标识 YYYYMMDD-HH */
-function currentHourTag() {
-    const d = new Date();
-    const pad = (n) => String(n).padStart(2, '0');
-    return `${d.getFullYear()}${pad(d.getMonth() + 1)}${pad(d.getDate())}-${pad(d.getHours())}`;
-}
-/** 清理超过 RETAIN_HOURS 的旧日志文件 */
-function cleanupOldLogs() {
-    const cutoff = Date.now() - RETAIN_HOURS * HOUR_MS;
-    try {
-        for (const name of fs.readdirSync(LOG_DIR)) {
-            if (!LOG_FILE_RE.test(name))
-                continue;
-            try {
-                const full = path.join(LOG_DIR, name);
-                if (fs.statSync(full).mtimeMs < cutoff)
-                    fs.unlinkSync(full);
-            }
-            catch { }
-        }
-    }
-    catch { }
-}
-let mainHourTag = currentHourTag();
-let mainStream = fs.createWriteStream(path.join(LOG_DIR, `evolclaw-${mainHourTag}.log`), { flags: 'a' });
-// 同时保留 evolclaw.log 软链接指向当前文件，方便 tail -f
-function updateSymlink() {
-    const link = path.join(LOG_DIR, 'evolclaw.log');
-    const target = `evolclaw-${mainHourTag}.log`;
-    try {
-        fs.unlinkSync(link);
-    }
-    catch { }
-    try {
-        fs.symlinkSync(target, link);
-    }
-    catch { }
-}
-updateSymlink();
-// 启动时清理一次，之后每小时清理
-cleanupOldLogs();
-const cleanupTimer = setInterval(cleanupOldLogs, HOUR_MS);
-cleanupTimer.unref?.();
-function rotateMainIfNeeded() {
-    const tag = currentHourTag();
-    if (tag === mainHourTag)
-        return;
-    mainStream.end();
-    mainHourTag = tag;
-    mainStream = fs.createWriteStream(path.join(LOG_DIR, `evolclaw-${mainHourTag}.log`), { flags: 'a' });
-    updateSymlink();
-    cleanupOldLogs();
-}
-const streams = {
-    message: config.messageLog ? fs.createWriteStream(path.join(LOG_DIR, 'messages.log'), { flags: 'a' }) : null,
-    event: config.eventLog ? fs.createWriteStream(path.join(LOG_DIR, 'events.log'), { flags: 'a' }) : null
-};
+// 主日志：按小时切片，保留 12 小时
+const mainWriter = new LogWriter({
+    baseName: 'evolclaw',
+    logDir: LOG_DIR,
+    rotation: 'hourly',
+    retention: { hours: 12 },
+});
+// 消息日志：按小时切片，保留 12 小时
+const messageWriter = config.messageLog
+    ? new LogWriter({ baseName: 'messages', logDir: LOG_DIR, rotation: 'hourly', retention: { hours: 12 } })
+    : null;
+// 事件日志：按小时切片，保留 12 小时（由 index.ts 订阅 EventBus 后填充）
+const eventWriter = config.eventLog
+    ? new LogWriter({ baseName: 'events', logDir: LOG_DIR, rotation: 'hourly', retention: { hours: 12 } })
+    : null;
+// 渠道入站日志：记录从渠道收到的原始消息
+const channelInWriter = new LogWriter({ baseName: 'channel-in', logDir: LOG_DIR, rotation: 'hourly', retention: { hours: 12 } });
+// 渠道出站日志：记录发往渠道的所有消息
+const channelOutWriter = new LogWriter({ baseName: 'channel-out', logDir: LOG_DIR, rotation: 'hourly', retention: { hours: 12 } });
 function shouldLog(level) {
     return (LEVELS[level] ?? 1) >= (LEVELS[currentLevel] ?? 1);
 }
-function write(stream, data) {
-    if (!stream)
-        return;
-    const line = typeof data === 'string' ? data : JSON.stringify(data);
-    stream.write(`${line}\n`);
-}
 export function localTimestamp() {
     const d = new Date();
     const pad = (n) => String(n).padStart(2, '0');
@@ -88,10 +37,8 @@ export function localTimestamp() {
 function log(level, ...args) {
     if (!shouldLog(level))
         return;
-    rotateMainIfNeeded();
-    const timestamp = localTimestamp();
-    const msg = `[${timestamp}] [${level}] ${args.join(' ')}`;
-    mainStream.write(msg + '\n');
+    const msg = `[${localTimestamp()}] [${level}] ${args.join(' ')}`;
+    mainWriter.write(msg);
 }
 /**
  * 设置日志级别（config 加载后调用，覆盖环境变量默认值）
@@ -112,9 +59,19 @@ export const logger = {
     warn: (...args) => log('WARN', ...args),
     error: (...args) => log('ERROR', ...args),
     message: (data) => {
-        write(streams.message, { ts: localTimestamp(), ...data });
+        if (!messageWriter)
+            return;
+        messageWriter.write(JSON.stringify({ ts: localTimestamp(), ...data }));
     },
     event: (data) => {
-        write(streams.event, { ts: localTimestamp(), ...data });
+        if (!eventWriter)
+            return;
+        eventWriter.write(JSON.stringify({ ts: localTimestamp(), ...data }));
+    },
+    channelIn: (data) => {
+        channelInWriter.write(JSON.stringify({ ts: localTimestamp(), ...data }));
+    },
+    channelOut: (data) => {
+        channelOutWriter.write(JSON.stringify({ ts: localTimestamp(), ...data }));
     }
 };

package/dist/utils/media-cache.js

@@ -207,3 +207,26 @@ export class DownloadCache {
         this.cache.clear();
     }
 }
+// ── MIME / Size helpers ──────────────────────────────────────────────────────
+const MIME_MAP = {
+    '.txt': 'text/plain', '.md': 'text/markdown', '.json': 'application/json',
+    '.js': 'text/javascript', '.ts': 'text/typescript', '.py': 'text/x-python',
+    '.html': 'text/html', '.css': 'text/css', '.csv': 'text/csv',
+    '.pdf': 'application/pdf', '.zip': 'application/zip', '.gz': 'application/gzip',
+    '.png': 'image/png', '.jpg': 'image/jpeg', '.jpeg': 'image/jpeg',
+    '.gif': 'image/gif', '.webp': 'image/webp', '.svg': 'image/svg+xml',
+    '.xml': 'application/xml', '.yaml': 'application/x-yaml', '.yml': 'application/x-yaml',
+    '.mp4': 'video/mp4', '.mov': 'video/quicktime', '.webm': 'video/webm', '.avi': 'video/x-msvideo',
+    '.opus': 'audio/ogg', '.mp3': 'audio/mpeg', '.aac': 'audio/aac', '.m4a': 'audio/mp4', '.wav': 'audio/wav',
+};
+export function guessMime(filename) {
+    const ext = path.extname(filename).toLowerCase();
+    return MIME_MAP[ext] || 'application/octet-stream';
+}
+export function formatSize(bytes) {
+    if (bytes < 1024)
+        return `${bytes} B`;
+    if (bytes < 1048576)
+        return `${(bytes / 1024).toFixed(1)} KB`;
+    return `${(bytes / 1048576).toFixed(1)} MB`;
+}

package/dist/utils/npm-ops.js

@@ -0,0 +1,163 @@
+/**
+ * npm operations
+ *
+ * 集中管理本仓库所有 `npm install -g` / `npm view` 相关的子进程调用：
+ *  - tryUpgrade()       — evolclaw 自我升级
+ *  - requireOptional()  — 可选依赖动态加载 + 自动安装
+ *  - npmInstallGlobal() — 全局安装（含 EACCES → sudo 回退、Windows npm.cmd）
+ */
+import fs from 'fs';
+import path from 'path';
+import { execFile } from 'child_process';
+import { promisify } from 'util';
+import { getPackageRoot } from '../paths.js';
+import { isWindows } from './cross-platform.js';
+const execFileAsync = promisify(execFile);
+// ── npm install -g (shared) ────────────────────────────────────────────────
+export async function npmInstallGlobal(pkg) {
+    const npmCmd = isWindows ? 'npm.cmd' : 'npm';
+    const execOpts = { timeout: 180000, shell: isWindows };
+    try {
+        await execFileAsync(npmCmd, ['install', '-g', pkg], execOpts);
+    }
+    catch (e) {
+        if (e.stderr?.includes('EACCES') || e.message?.includes('EACCES')) {
+            if (isWindows) {
+                throw new Error('权限不足。请以管理员身份运行 PowerShell 或 CMD，然后重试');
+            }
+            await execFileAsync('sudo', ['npm', 'install', '-g', pkg], { timeout: 180000 });
+        }
+        else {
+            throw e;
+        }
+    }
+}
+/** Dynamic import with auto-install fallback for optional dependencies */
+export async function requireOptional(pkg, autoInstall = true) {
+    try {
+        return await import(pkg);
+    }
+    catch (e) {
+        if (e.code !== 'ERR_MODULE_NOT_FOUND' && e.code !== 'MODULE_NOT_FOUND')
+            throw e;
+        if (!autoInstall)
+            throw new Error(`依赖 ${pkg} 未安装。请运行: npm install -g ${pkg}`);
+        const { logger } = await import('./logger.js');
+        logger.info(`正在安装可选依赖 ${pkg}...`);
+        await npmInstallGlobal(pkg);
+        return await import(pkg);
+    }
+}
+/**
+ * 比较两个 semver 版本号 (a.b.c 格式)
+ * 返回 -1 (a < b), 0 (a == b), 1 (a > b)
+ * 自动剥离 pre-release 标签 (e.g. 2.6.0-beta.1 → 2.6.0)
+ */
+export function compareVersions(a, b) {
+    const pa = a.split('-')[0].split('.').map(Number);
+    const pb = b.split('-')[0].split('.').map(Number);
+    const len = Math.max(pa.length, pb.length);
+    for (let i = 0; i < len; i++) {
+        const na = pa[i] ?? 0;
+        const nb = pb[i] ?? 0;
+        if (na < nb)
+            return -1;
+        if (na > nb)
+            return 1;
+    }
+    return 0;
+}
+/**
+ * 检查当前安装是否为 npm link 开发模式。
+ * 正式全局安装的路径结构为 .../node_modules/evolclaw，
+ * 而 npm link 指向项目源码目录，其父目录不是 node_modules。
+ */
+export function isLinkedInstall() {
+    const pkgRoot = getPackageRoot();
+    return path.basename(path.dirname(pkgRoot)) !== 'node_modules';
+}
+/** 获取本地 package.json 中的版本号 */
+export function getLocalVersion() {
+    const pkgPath = path.join(getPackageRoot(), 'package.json');
+    const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+    return pkg.version;
+}
+/**
+ * 查询 npm registry 上指定包的最新版本。
+ * 超时 15 秒，失败返回 null。
+ */
+export function checkLatestVersion(pkg = 'evolclaw') {
+    return new Promise((resolve) => {
+        execFile('npm', ['view', pkg, 'version'], { timeout: 15000 }, (err, stdout) => {
+            if (err) {
+                resolve(null);
+                return;
+            }
+            const ver = stdout.trim();
+            resolve(ver || null);
+        });
+    });
+}
+/**
+ * 完整升级流程：检查 → 比较 → 安装（失败重试一次）
+ */
+export async function tryUpgrade() {
+    // 开发模式跳过
+    if (isLinkedInstall()) {
+        return { status: 'skipped' };
+    }
+    const localVer = getLocalVersion();
+    // 查询 registry
+    const remoteVer = await checkLatestVersion();
+    if (!remoteVer) {
+        return { status: 'skipped', error: 'Failed to check remote version' };
+    }
+    // 版本比较
+    if (compareVersions(localVer, remoteVer) >= 0) {
+        return { status: 'no-update', from: localVer };
+    }
+    // 有新版本，执行升级（失败重试一次）
+    let lastError;
+    for (let attempt = 0; attempt < 2; attempt++) {
+        try {
+            await npmInstallGlobal('evolclaw@latest');
+            return { status: 'upgraded', from: localVer, to: remoteVer };
+        }
+        catch (e) {
+            lastError = e.stderr || e.message || String(e);
+        }
+    }
+    return { status: 'failed', from: localVer, to: remoteVer, error: lastError };
+}
+/**
+ * AUN SDK 升级流程：检查 → 比较 → 安装
+ * 仅在 SDK 已安装时检查升级，未安装则跳过。
+ */
+export async function tryUpgradeAunSdk(resolveAunCoreSdkPkg, AUN_CORE_SDK_PKG) {
+    if (isLinkedInstall()) {
+        return { status: 'skipped' };
+    }
+    const installed = resolveAunCoreSdkPkg();
+    if (!installed) {
+        return { status: 'skipped' }; // SDK not installed, skip
+    }
+    const localVer = installed.version;
+    const remoteVer = await checkLatestVersion(AUN_CORE_SDK_PKG);
+    if (!remoteVer) {
+        return { status: 'skipped', error: 'Failed to check remote version' };
+    }
+    if (compareVersions(localVer, remoteVer) >= 0) {
+        return { status: 'no-update', from: localVer };
+    }
+    let lastError;
+    for (let attempt = 0; attempt < 2; attempt++) {
+        try {
+            await npmInstallGlobal(`${AUN_CORE_SDK_PKG}@latest`);
+            return { status: 'upgraded', from: localVer, to: remoteVer };
+        }
+        catch (e) {
+            lastError = e.stderr || e.message || String(e);
+        }
+    }
+    return { status: 'failed', from: localVer, to: remoteVer, error: lastError };
+}

package/dist/utils/process-introspect.js

@@ -0,0 +1,122 @@
+/**
+ * Cross-platform process introspection.
+ *
+ * Provides process start time retrieval for PID reuse detection.
+ * Returns null when start time cannot be obtained — callers should treat
+ * this as "do not match" (conservative: prefer leaving an orphan over
+ * killing the wrong process).
+ */
+import fs from 'fs';
+import { spawnSync } from 'child_process';
+import { isWindows } from './cross-platform.js';
+const isMacOS = process.platform === 'darwin';
+/** 容差：2 秒（覆盖 macOS 秒级精度 + 时钟漂移） */
+export const START_TIME_TOLERANCE_MS = 2000;
+/**
+ * 获取进程启动时间（Unix 毫秒）。
+ * 拿不到时返回 null，调用方应保守处理（不杀该 PID）。
+ */
+export function getProcessStartTime(pid) {
+    try {
+        if (isWindows)
+            return getStartTimeWindows(pid);
+        if (isMacOS)
+            return getStartTimeMacOS(pid);
+        return getStartTimeLinux(pid);
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * 比对记录的启动时间与实际启动时间是否匹配（容差 2 秒）。
+ * actual === null 时返回 false（保守不匹配）。
+ */
+export function startTimeMatches(recorded, actual) {
+    if (actual === null)
+        return false;
+    return Math.abs(recorded - actual) < START_TIME_TOLERANCE_MS;
+}
+// ── Linux ──
+function getStartTimeLinux(pid) {
+    let stat;
+    try {
+        stat = fs.readFileSync(`/proc/${pid}/stat`, 'utf-8');
+    }
+    catch {
+        return null;
+    }
+    const tail = stat.slice(stat.lastIndexOf(')') + 2);
+    const fields = tail.split(' ');
+    const starttimeJiffies = parseInt(fields[19], 10);
+    if (isNaN(starttimeJiffies))
+        return null;
+    let uptimeSec;
+    try {
+        uptimeSec = parseFloat(fs.readFileSync('/proc/uptime', 'utf-8').split(' ')[0]);
+    }
+    catch {
+        return null;
+    }
+    if (isNaN(uptimeSec))
+        return null;
+    const clkTck = 100;
+    const bootTimeMs = Date.now() - uptimeSec * 1000;
+    return bootTimeMs + (starttimeJiffies / clkTck) * 1000;
+}
+// ── macOS ──
+function getStartTimeMacOS(pid) {
+    const result = spawnSync('ps', ['-p', String(pid), '-o', 'lstart='], {
+        encoding: 'utf-8',
+        timeout: 5000,
+        stdio: ['pipe', 'pipe', 'pipe'],
+    });
+    const out = result.stdout?.trim();
+    if (!out)
+        return null;
+    const t = Date.parse(out);
+    return isNaN(t) ? null : t;
+}
+// ── Windows ──
+function getStartTimeWindows(pid) {
+    const fromPwsh = winPowerShellCreationDate(pid);
+    if (fromPwsh !== null)
+        return fromPwsh;
+    return winWmicCreationDate(pid);
+}
+function winPowerShellCreationDate(pid) {
+    const result = spawnSync('powershell', [
+        '-NoProfile',
+        '-Command',
+        `(Get-CimInstance Win32_Process -Filter 'ProcessId=${pid}').CreationDate`,
+    ], { encoding: 'utf-8', timeout: 8000, stdio: ['pipe', 'pipe', 'pipe'], windowsHide: true });
+    const out = result.stdout?.trim();
+    if (!out)
+        return null;
+    return parseCimDate(out);
+}
+function winWmicCreationDate(pid) {
+    const result = spawnSync('wmic', ['process', 'where', `ProcessId=${pid}`, 'get', 'CreationDate', '/value'], { encoding: 'utf-8', timeout: 5000, stdio: ['pipe', 'pipe', 'pipe'], windowsHide: true });
+    const out = result.stdout || '';
+    const m = out.match(/CreationDate=([^\r\n]+)/);
+    if (!m)
+        return null;
+    return parseCimDate(m[1].trim());
+}
+/**
+ * 解析 CIM/WMI 日期格式：yyyyMMddHHmmss.ffffff±TZZZ
+ * TZZZ 是相对 UTC 的分钟偏移（中国是 +480）
+ */
+export function parseCimDate(s) {
+    if (!s)
+        return null;
+    const m = s.match(/^(\d{4})(\d{2})(\d{2})(\d{2})(\d{2})(\d{2})\.(\d{6})([+-]\d+)$/);
+    if (!m)
+        return null;
+    const [, y, mo, d, h, mi, sec, us, tz] = m;
+    const tzMin = parseInt(tz, 10);
+    if (isNaN(tzMin))
+        return null;
+    const localUtcMs = Date.UTC(+y, +mo - 1, +d, +h, +mi, +sec, Math.floor(+us / 1000));
+    return localUtcMs - tzMin * 60 * 1000;
+}

package/dist/utils/stats.js

@@ -0,0 +1,192 @@
+export class StatsCollector {
+    events = [];
+    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('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;
+            this.recordEvent({ type: 'error', timestamp: Date.now(), errorType: e.errorType, agentName: e.agentName });
+        });
+        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) {
+                this.recordEvent({ type: 'tool-error', timestamp: Date.now(), toolName: e.toolName, agentName: e.agentName });
+            }
+        });
+    }
+    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 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 '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;
+            }
+        }
+        return {
+            uptimeMs: now - this.startTime,
+            lastHour: {
+                received,
+                completed,
+                errors,
+                errorsByType,
+                toolErrors,
+                toolErrorsByName,
+                interrupts,
+                avgResponseMs: durationCount > 0 ? totalDuration / durationCount : 0
+            }
+        };
+    }
+}
+export class AidStatsCollector {
+    entries = new Map();
+    queueStatsProvider;
+    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,
+                lastSentText: null,
+                lastSentTo: null,
+                uniquePeers: new Set(),
+            };
+            this.entries.set(aid, entry);
+        }
+        return entry;
+    }
+    setSelfName(aid, name) {
+        const entry = this.getOrCreate(aid);
+        entry.selfName = name;
+    }
+    recordInbound(aid, fromPeer, byteLength, text, isSystem = false) {
+        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;
+        }
+        entry.bytesReceived += byteLength;
+        entry.uniquePeers.add(fromPeer);
+    }
+    recordOutbound(aid, toPeer, byteLength, text, isSystem = false) {
+        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;
+        }
+        entry.bytesSent += byteLength;
+        entry.uniquePeers.add(toPeer);
+    }
+    getAllSnapshots() {
+        const out = [];
+        for (const entry of this.entries.values()) {
+            const queueStats = this.queueStatsProvider
+                ? this.queueStatsProvider(entry.aid)
+                : { processing: 0, queued: 0 };
+            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,
+                lastSentText: entry.lastSentText,
+                lastSentTo: entry.lastSentTo,
+                uniquePeerCount: entry.uniquePeers.size,
+                processing: queueStats.processing,
+                queued: queueStats.queued,
+            });
+        }
+        return out;
+    }
+}