@bolloon/bolloon-agent 0.2.9 → 0.2.11

package/dist/test/p2p-two-nodes-test.js

@@ -0,0 +1,438 @@
+/**
+ * P2P Two-Node Discovery Test
+ * 测试两个不同端口的节点能否发现彼此并进行 P2P 交流
+ *
+ * 运行方式: npx tsx src/test/p2p-two-nodes-test.ts
+ */
+import { config } from 'dotenv';
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import express from 'express';
+import crypto from 'crypto';
+config();
+const CONFIG_DIR = path.join(process.env.HOME || '/tmp', '.bolloon', 'p2p-test');
+const NODES_FILE = path.join(CONFIG_DIR, 'nodes.json');
+class NodeRegistry {
+    nodes = new Map();
+    async init() {
+        await fs.mkdir(CONFIG_DIR, { recursive: true });
+        try {
+            const data = await fs.readFile(NODES_FILE, 'utf-8');
+            const nodes = JSON.parse(data);
+            for (const n of nodes) {
+                this.nodes.set(n.id, n);
+            }
+            console.log(`[Registry] Loaded ${nodes.length} nodes`);
+        }
+        catch {
+            console.log('[Registry] Starting fresh');
+        }
+    }
+    async registerNode(node) {
+        node.lastSeen = Date.now();
+        this.nodes.set(node.id, node);
+        await this.save();
+    }
+    async unregisterNode(id) {
+        this.nodes.delete(id);
+        await this.save();
+    }
+    getNodes() {
+        return Array.from(this.nodes.values()).filter(n => Date.now() - n.lastSeen < 60000);
+    }
+    getNodeById(id) {
+        return this.nodes.get(id);
+    }
+    getOtherNodes(myId) {
+        return this.getNodes().filter(n => n.id !== myId);
+    }
+    async save() {
+        const nodes = Array.from(this.nodes.values());
+        await fs.writeFile(NODES_FILE, JSON.stringify(nodes, null, 2));
+    }
+}
+class P2PNode {
+    id;
+    name;
+    port;
+    topic;
+    privateKey;
+    publicKey;
+    server = null;
+    registry;
+    connectedPeers = new Set();
+    messageHandlers = new Map();
+    heartbeatInterval = null;
+    constructor(name, port, registry) {
+        this.id = crypto.randomUUID();
+        this.name = name;
+        this.port = port;
+        this.topic = 'bolloon-p2p-test';
+        this.privateKey = crypto.getRandomValues(new Uint8Array(32));
+        this.publicKey = Buffer.from(this.privateKey.slice(0, 16)).toString('hex');
+        this.registry = registry;
+    }
+    async start() {
+        const app = express();
+        app.use(express.json());
+        // 健康检查
+        app.get('/health', (req, res) => {
+            res.json({
+                id: this.id,
+                name: this.name,
+                port: this.port,
+                peers: Array.from(this.connectedPeers),
+                publicKey: this.publicKey.substring(0, 16) + '...'
+            });
+        });
+        // 发现端点 - 广播自己的存在
+        app.get('/discovery', (req, res) => {
+            res.json({
+                id: this.id,
+                name: this.name,
+                port: this.port,
+                topic: this.topic,
+                publicKey: this.publicKey
+            });
+        });
+        // 发现所有节点
+        app.get('/nodes', async (req, res) => {
+            // 先尝试发现本地网络上的其他节点
+            const localNodes = await this.discoverLocalNodes();
+            const registeredNodes = this.registry.getOtherNodes(this.id);
+            const allNodes = [...localNodes, ...registeredNodes];
+            const uniqueNodes = new Map();
+            for (const n of allNodes) {
+                uniqueNodes.set(n.id, n);
+            }
+            res.json(Array.from(uniqueNodes.values()));
+        });
+        // 消息端点
+        app.post('/message', (req, res) => {
+            const { type, to, content } = req.body;
+            const msg = {
+                type,
+                from: this.id,
+                to,
+                content,
+                timestamp: Date.now(),
+                id: crypto.randomUUID()
+            };
+            this.handleMessage(msg, 'local');
+            res.json({ ok: true, msgId: msg.id });
+        });
+        // 接收其他节点的消息
+        app.post('/relay', async (req, res) => {
+            const { type, from, content } = req.body;
+            const msg = {
+                type,
+                from,
+                to: this.id,
+                content,
+                timestamp: Date.now(),
+                id: crypto.randomUUID()
+            };
+            this.handleMessage(msg, 'relay');
+            res.json({ ok: true });
+        });
+        this.server = app.listen(this.port, () => {
+            console.log(`✓ [${this.name}] 启动成功 on port ${this.port}`);
+            console.log(`  ID: ${this.id}`);
+            console.log(`  Public Key: ${this.publicKey.substring(0, 16)}...`);
+        });
+        // 注册到中心注册表
+        await this.registry.registerNode({
+            id: this.id,
+            port: this.port,
+            name: this.name,
+            publicKey: this.publicKey,
+            lastSeen: Date.now(),
+            topic: this.topic
+        });
+        // 启动心跳
+        this.startHeartbeat();
+    }
+    async discoverLocalNodes() {
+        const nodes = [];
+        const ports = [3001, 3002, 3003, 3004, 3005];
+        for (const p of ports) {
+            if (p === this.port)
+                continue;
+            try {
+                const resp = await fetch(`http://localhost:${p}/discovery`, {
+                    signal: AbortSignal.timeout(1000)
+                });
+                if (resp.ok) {
+                    const info = await resp.json();
+                    if (info.topic === this.topic) {
+                        nodes.push({
+                            id: info.id,
+                            port: info.port,
+                            name: info.name,
+                            publicKey: info.publicKey,
+                            lastSeen: Date.now(),
+                            topic: info.topic
+                        });
+                    }
+                }
+            }
+            catch {
+                // 节点不存在
+            }
+        }
+        return nodes;
+    }
+    startHeartbeat() {
+        // 每 5 秒更新注册表并尝试发现新节点
+        this.heartbeatInterval = setInterval(async () => {
+            await this.registry.registerNode({
+                id: this.id,
+                port: this.port,
+                name: this.name,
+                publicKey: this.publicKey,
+                lastSeen: Date.now(),
+                topic: this.topic
+            });
+            // 发现邻居
+            const neighbors = this.registry.getOtherNodes(this.id);
+            for (const n of neighbors) {
+                if (!this.connectedPeers.has(n.id)) {
+                    await this.connectToPeer(n);
+                }
+            }
+            // 广播存在到本地网络
+            this.broadcastPresence();
+        }, 5000);
+    }
+    async connectToPeer(peer) {
+        try {
+            // 尝试直接连接
+            const resp = await fetch(`http://localhost:${peer.port}/discovery`, {
+                signal: AbortSignal.timeout(1000)
+            });
+            if (resp.ok) {
+                this.connectedPeers.add(peer.id);
+                console.log(`✓ [${this.name}] 连接成功: ${peer.name} (${peer.id.substring(0, 8)}...)`);
+            }
+        }
+        catch {
+            // 连接失败
+        }
+    }
+    async broadcastPresence() {
+        // 广播自己的存在到本地网络
+        const ports = [3001, 3002, 3003, 3004, 3005];
+        for (const p of ports) {
+            if (p === this.port)
+                continue;
+            try {
+                await fetch(`http://localhost:${p}/relay`, {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify({
+                        type: 'presence',
+                        from: this.id,
+                        content: JSON.stringify({
+                            name: this.name,
+                            port: this.port,
+                            publicKey: this.publicKey
+                        })
+                    }),
+                    signal: AbortSignal.timeout(500)
+                });
+            }
+            catch {
+                // 节点不存在
+            }
+        }
+    }
+    onMessage(type, handler) {
+        this.messageHandlers.set(type, handler);
+    }
+    handleMessage(msg, source) {
+        const handler = this.messageHandlers.get(msg.type);
+        if (handler) {
+            handler(msg, source === 'local' ? msg.from : source);
+        }
+    }
+    async sendMessage(toId, type, content) {
+        const peer = this.registry.getNodeById(toId);
+        if (!peer) {
+            console.log(`[${this.name}] Unknown peer: ${toId}`);
+            return;
+        }
+        try {
+            await fetch(`http://localhost:${peer.port}/message`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ type, to: toId, content })
+            });
+        }
+        catch (err) {
+            console.log(`[${this.name}] Failed to send message to ${toId}:`, err);
+        }
+    }
+    async broadcast(type, content) {
+        const msg = {
+            type,
+            from: this.id,
+            content,
+            timestamp: Date.now(),
+            id: crypto.randomUUID()
+        };
+        // 广播到本地网络
+        const ports = [3001, 3002, 3003, 3004, 3005];
+        for (const p of ports) {
+            if (p === this.port)
+                continue;
+            try {
+                await fetch(`http://localhost:${p}/relay`, {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify({
+                        type,
+                        from: this.id,
+                        content: JSON.stringify(msg)
+                    }),
+                    signal: AbortSignal.timeout(500)
+                });
+            }
+            catch {
+                // 节点不存在
+            }
+        }
+    }
+    getPeers() {
+        return Array.from(this.connectedPeers);
+    }
+    async stop() {
+        if (this.heartbeatInterval) {
+            clearInterval(this.heartbeatInterval);
+        }
+        if (this.server) {
+            await new Promise(resolve => this.server.close(resolve));
+        }
+        await this.registry.unregisterNode(this.id);
+    }
+}
+// ============================================================================
+// 测试场景
+// ============================================================================
+async function runTest() {
+    console.log('\n========================================');
+    console.log('  P2P Two-Node Discovery & Harness Test');
+    console.log('========================================\n');
+    const registry = new NodeRegistry();
+    await registry.init();
+    // 清理旧数据
+    try {
+        await fs.unlink(NODES_FILE);
+    }
+    catch { }
+    // 创建两个节点
+    const node1 = new P2PNode('Alice-Node', 3001, registry);
+    const node2 = new P2PNode('Bob-Node', 3002, registry);
+    console.log('━━━ 步骤 1: 启动两个节点 ━━━\n');
+    await node1.start();
+    await node2.start();
+    console.log('\n━━━ 步骤 2: 等待节点发现 (3秒) ━━━\n');
+    await new Promise(resolve => setTimeout(resolve, 3000));
+    // 列出发现的节点
+    console.log('━━━ 步骤 3: 检查节点发现 ━━━\n');
+    const node1Peers = node1.getPeers();
+    const node2Peers = node2.getPeers();
+    console.log(`[Alice] 发现 ${node1Peers.length} 个邻居: ${node1Peers.map(p => p.substring(0, 8)).join(', ') || '无'}`);
+    console.log(`[Bob] 发现 ${node2Peers.length} 个邻居: ${node2Peers.map(p => p.substring(0, 8)).join(', ') || '无'}`);
+    // 如果没有发现，尝试手动连接
+    if (node1Peers.length === 0 && node2Peers.length === 0) {
+        console.log('\n⚠️ 节点未自动发现，手动连接...\n');
+        // 模拟手动连接
+        node1.connectedPeers.add(node2.id);
+        node2.connectedPeers.add(node1.id);
+        console.log(`✓ [Alice] 手动连接到 Bob`);
+        console.log(`✓ [Bob] 手动连接到 Alice`);
+    }
+    console.log('\n━━━ 步骤 4: 测试消息发送 ━━━\n');
+    // 设置消息处理器
+    node2.onMessage('ping', (msg, from) => {
+        console.log(`[Bob] 收到来自 ${msg.from.substring(0, 8)}... 的消息: ${msg.content}`);
+        // 回复 pong
+        node2.sendMessage(msg.from, 'pong', 'Pong from Bob!');
+    });
+    node1.onMessage('pong', (msg, from) => {
+        console.log(`[Alice] 收到回复: ${msg.content}`);
+    });
+    node1.onMessage('presence', (msg, from) => {
+        const info = JSON.parse(msg.content);
+        console.log(`[Alice] 发现新节点: ${info.name} on port ${info.port}`);
+        node1.connectedPeers.add(msg.from);
+    });
+    node2.onMessage('presence', (msg, from) => {
+        const info = JSON.parse(msg.content);
+        console.log(`[Bob] 发现新节点: ${info.name} on port ${info.port}`);
+        node2.connectedPeers.add(msg.from);
+    });
+    // Alice 发送 ping 给 Bob
+    await node1.sendMessage(node2.id, 'ping', 'Hello Bob, this is Alice!');
+    console.log('[Alice] 发送 ping 给 Bob...');
+    await new Promise(resolve => setTimeout(resolve, 1000));
+    console.log('\n━━━ 步骤 5: 测试 Harness 同步 ━━━\n');
+    // 模拟 Harness 同步消息
+    const harnessSync = {
+        gate: 3,
+        skills: ['arch', 'lead', 'harness-eng'],
+        agents: [node1.id, node2.id],
+        timestamp: Date.now()
+    };
+    console.log(`[Harness Sync] Gate: ${harnessSync.gate}`);
+    console.log(`[Harness Sync] Skills: ${harnessSync.skills.join(', ')}`);
+    console.log(`[Harness Sync] Agents: ${harnessSync.agents.map(a => a.substring(0, 8)).join(', ')}...`);
+    // 设置 harness 消息处理器
+    node1.onMessage('harness-sync', (msg, from) => {
+        console.log(`\n[Alice] 收到 Harness 同步消息:`);
+        const sync = JSON.parse(msg.content);
+        console.log(`  Gate: ${sync.gate}`);
+        console.log(`  Skills: ${sync.skills.join(', ')}`);
+    });
+    node2.onMessage('harness-sync', (msg, from) => {
+        console.log(`\n[Bob] 收到 Harness 同步消息:`);
+        const sync = JSON.parse(msg.content);
+        console.log(`  Gate: ${sync.gate}`);
+        console.log(`  Skills: ${sync.skills.join(', ')}`);
+    });
+    // 广播 Harness 同步消息
+    await node1.broadcast('harness-sync', JSON.stringify(harnessSync));
+    console.log('\n[Alice] 广播 Harness 同步消息到网络...\n');
+    await new Promise(resolve => setTimeout(resolve, 1000));
+    console.log('\n━━━ 步骤 6: 最终状态检查 ━━━\n');
+    const finalNode1Peers = node1.getPeers();
+    const finalNode2Peers = node2.getPeers();
+    console.log(`[Alice] 最终邻居数: ${finalNode1Peers.length}`);
+    console.log(`[Bob] 最终邻居数: ${finalNode2Peers.length}`);
+    // 获取节点健康信息
+    try {
+        const aliceHealth = await fetch('http://localhost:3001/health').then(r => r.json());
+        const bobHealth = await fetch('http://localhost:3002/health').then(r => r.json());
+        console.log('\n[Alice Health]');
+        console.log(`  ID: ${aliceHealth.id.substring(0, 16)}...`);
+        console.log(`  Peers: ${aliceHealth.peers.length}`);
+        console.log('\n[Bob Health]');
+        console.log(`  ID: ${bobHealth.id.substring(0, 16)}...`);
+        console.log(`  Peers: ${bobHealth.peers.length}`);
+    }
+    catch (err) {
+        console.log('Health check failed:', err);
+    }
+    // 清理
+    console.log('\n━━━ 清理资源 ━━━\n');
+    await node1.stop();
+    await node2.stop();
+    console.log('✓ 两个节点已停止');
+    console.log('\n========================================');
+    console.log('  测试完成');
+    console.log('========================================\n');
+}
+runTest().catch(err => {
+    console.error('Test failed:', err);
+    process.exit(1);
+});

package/dist/test/pi-sdk.test.js

@@ -0,0 +1,44 @@
+import { config } from 'dotenv';
+import { describe, it, expect } from 'vitest';
+import { createAgentSession } from '../agents/pi-sdk.js';
+import { initMinimax } from '../constraints/index.js';
+import * as path from 'path';
+config();
+async function isMinimaxAvailable() {
+    const apiKey = process.env.MINIMAX_API_KEY;
+    if (!apiKey)
+        return false;
+    try {
+        initMinimax({ apiKey });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+describe('Pi SDK', () => {
+    it('basic agent session', async () => {
+        const session = await createAgentSession({ cwd: process.cwd() });
+        const result = await session.prompt('简单问候');
+        expect(result).toContain('我是一个文档处理智能体');
+    });
+    it('document analysis', async () => {
+        const available = await isMinimaxAvailable();
+        if (!available) {
+            return;
+        }
+        const testFile = path.join(process.cwd(), 'README.md');
+        const session = await createAgentSession({ cwd: process.cwd() });
+        const result = await session.summarizeDocument(testFile, '测试文档分析');
+        expect(result.summary).toBeDefined();
+    });
+    it('minimax LLM integration', { timeout: 30000 }, async () => {
+        const available = await isMinimaxAvailable();
+        if (!available) {
+            return;
+        }
+        const session = await createAgentSession({ cwd: process.cwd() });
+        const result = await session.prompt('总结: 这是一个测试文档，用于验证LLM摘要功能。');
+        expect(result).toBeDefined();
+    });
+});

package/dist/test/set-persona.js

@@ -0,0 +1,40 @@
+import { config } from 'dotenv';
+import * as path from 'path';
+import * as fs from 'fs/promises';
+config();
+const PERSONA_TEMPLATE_PATH = path.join('src', 'bollharness', 'templates', 'persona', 'default.json');
+const PERSONA_PATH = path.join(process.env.HOME || '/tmp', '.bolloon', 'persona.json');
+async function loadPersonaTemplate() {
+    const content = await fs.readFile(PERSONA_TEMPLATE_PATH, 'utf-8');
+    const persona = JSON.parse(content);
+    persona.createdAt = new Date().toISOString();
+    persona.updatedAt = new Date().toISOString();
+    return persona;
+}
+async function testSetPersona() {
+    console.log('=== 测试 set_persona 功能 ===\n');
+    const { createAgentSession } = await import('../agents/pi-sdk.js');
+    const session = await createAgentSession({ cwd: process.cwd() });
+    const originalIdentity = session.getIdentity();
+    console.log('原始身份:', originalIdentity.name);
+    const originalPersona = session.getPersona();
+    console.log('原始 persona:', originalPersona ? JSON.stringify(originalPersona, null, 2) : 'null');
+    const newPersona = await loadPersonaTemplate();
+    console.log('\n📄 从模板加载 persona:', JSON.stringify(newPersona, null, 2));
+    await session.setPersona(newPersona);
+    console.log('\n✅ 已设置新 persona');
+    const updatedIdentity = session.getIdentity();
+    console.log('更新后身份:', updatedIdentity.name);
+    const updatedPersona = session.getPersona();
+    console.log('更新后 persona:', updatedPersona ? JSON.stringify(updatedPersona, null, 2) : 'null');
+    console.log('\n📁 persona.json 路径:', PERSONA_PATH);
+    try {
+        const fileContent = await fs.readFile(PERSONA_PATH, 'utf-8');
+        console.log('📄 文件内容:', fileContent);
+    }
+    catch (e) {
+        console.log('读取文件失败:', e);
+    }
+    console.log('\n=== 测试完成 ===');
+}
+testSetPersona().catch(console.error);

package/dist/test/simple.test.js

@@ -0,0 +1,9 @@
+/**
+ * Simple Test - Just to verify vitest works
+ */
+import { describe, it, expect } from 'vitest';
+describe('Simple', () => {
+    it('should pass', () => {
+        expect(1 + 1).toBe(2);
+    });
+});

package/dist/test/storage-integration.test.js

@@ -0,0 +1,150 @@
+/**
+ * Storage Layer Integration Test
+ * 测试消息存储、离线队列和响应持久化
+ *
+ * 运行: npx tsx src/test/storage-integration.test.ts
+ */
+import { config } from 'dotenv';
+import * as fs from 'fs/promises';
+import * as path from 'path';
+config();
+const TEST_DIR = path.join(process.env.HOME || '/tmp', '.bolloon', 'test-messages');
+const TEST_CLEANUP = true;
+async function runStorageTest() {
+    console.log('\n========================================');
+    console.log('  Storage Layer Integration Test');
+    console.log('========================================\n');
+    // 清理测试目录
+    if (TEST_CLEANUP) {
+        try {
+            await fs.rm(TEST_DIR, { recursive: true, force: true });
+            console.log('✓ Cleaned test directory');
+        }
+        catch { }
+    }
+    // 导入存储层
+    console.log('━━━ 导入存储层 ━━━\n');
+    const { JsonMessageStore } = await import('../network/storage/adapters/json-adapter.js');
+    const { createMessageStore, createInMemoryStore } = await import('../network/storage/index.js');
+    // 测试 1: JSON 存储初始化
+    console.log('━━━ 测试 1: JSON 存储初始化 ━━━\n');
+    const jsonStore = new JsonMessageStore({ baseDir: TEST_DIR });
+    await jsonStore.initialize();
+    console.log('✓ JsonMessageStore initialized');
+    console.log(`  Base dir: ${TEST_DIR}`);
+    // 测试 2: 保存消息
+    console.log('\n━━━ 测试 2: 保存消息 ━━━\n');
+    const msg1 = await jsonStore.saveMessage({
+        direction: 'sent',
+        type: 'task',
+        payload: Buffer.from('Hello World').toString('base64'),
+        from: 'node-A',
+        to: 'node-B',
+        timestamp: Date.now(),
+        status: 'delivered',
+        retryCount: 0,
+    });
+    console.log('✓ Saved message');
+    console.log(`  ID: ${msg1.id}`);
+    console.log(`  Type: ${msg1.type}`);
+    console.log(`  Status: ${msg1.status}`);
+    // 测试 3: 查询消息
+    console.log('\n━━━ 测试 3: 查询消息 ━━━\n');
+    const allMessages = await jsonStore.getMessages();
+    console.log(`✓ Found ${allMessages.length} messages`);
+    const sentMessages = await jsonStore.getMessages({ direction: 'sent' });
+    console.log(`✓ Found ${sentMessages.length} sent messages`);
+    const taskMessages = await jsonStore.getMessages({ type: 'task' });
+    console.log(`✓ Found ${taskMessages.length} task messages`);
+    // 测试 4: 离线消息队列
+    console.log('\n━━━ 测试 4: 离线消息队列 ━━━\n');
+    const offline1 = await jsonStore.enqueueOfflineMessage({
+        targetNodeId: 'node-B',
+        type: 'urgent-task',
+        payload: Buffer.from('Urgent message').toString('base64'),
+        createdAt: Date.now(),
+        transport: 'libp2p',
+        retryCount: 0,
+    });
+    console.log('✓ Enqueued offline message');
+    console.log(`  ID: ${offline1.id}`);
+    console.log(`  Target: ${offline1.targetNodeId}`);
+    const pendingCount = await jsonStore.getPendingOfflineCount();
+    console.log(`✓ Pending offline count: ${pendingCount}`);
+    const nodeBMessages = await jsonStore.getOfflineMessages('node-B');
+    console.log(`✓ Messages for node-B: ${nodeBMessages.length}`);
+    // 测试 5: 待响应请求
+    console.log('\n━━━ 测试 5: 待响应请求 ━━━\n');
+    const pending = await jsonStore.savePendingResponse({
+        requestId: 'req-123',
+        type: 'task-request',
+        payload: 'Request payload',
+        fromNodeId: 'node-A',
+        timestamp: Date.now(),
+        timeout: 30000,
+    });
+    console.log('✓ Saved pending response');
+    console.log(`  ID: ${pending.id}`);
+    console.log(`  Request ID: ${pending.requestId}`);
+    const retrieved = await jsonStore.getPendingResponse('req-123');
+    console.log(`✓ Retrieved pending: ${retrieved ? 'found' : 'not found'}`);
+    await jsonStore.removePendingResponse('req-123');
+    console.log('✓ Removed pending response');
+    // 测试 6: 内存存储
+    console.log('\n━━━ 测试 6: 内存存储 ━━━\n');
+    const memStore = createInMemoryStore();
+    await memStore.initialize();
+    const memMsg = await memStore.saveMessage({
+        direction: 'received',
+        type: 'chat',
+        payload: 'In-memory message',
+        from: 'peer-X',
+        to: 'me',
+        timestamp: Date.now(),
+        status: 'pending',
+        retryCount: 0,
+    });
+    console.log('✓ Saved to in-memory store');
+    console.log(`  ID: ${memMsg.id}`);
+    await memStore.shutdown();
+    console.log('✓ In-memory store shutdown');
+    // 测试 7: 统计和清理
+    console.log('\n━━━ 测试 7: 统计和清理 ━━━\n');
+    const msgCount = await jsonStore.getMessageCount();
+    console.log(`✓ Total messages: ${msgCount}`);
+    const oldMessages = await jsonStore.getMessages({
+        endTime: Date.now() - 1000, // 1秒前
+    });
+    console.log(`✓ Old messages (< 1s): ${oldMessages.length}`);
+    // 测试 8: 工厂函数
+    console.log('\n━━━ 测试 8: 工厂函数 ━━━\n');
+    const store = await createMessageStore('libp2p', { baseDir: TEST_DIR });
+    console.log('✓ Created store via factory');
+    await store.shutdown();
+    console.log('✓ Store shutdown');
+    // 验证文件已创建
+    console.log('\n━━━ 验证存储文件 ━━━\n');
+    try {
+        const files = await fs.readdir(TEST_DIR);
+        console.log(`✓ Storage files created: ${files.length}`);
+        for (const file of files) {
+            console.log(`  - ${file}`);
+        }
+    }
+    catch (e) {
+        console.log('No storage files yet (messages not persisted to disk in this session)');
+    }
+    // 最终清理
+    await jsonStore.shutdown();
+    console.log('\n✓ All stores shutdown');
+    // 统计
+    console.log('\n========================================');
+    console.log('  测试完成');
+    console.log(`  消息数: ${msgCount}`);
+    console.log(`  离线消息: ${pendingCount}`);
+    console.log('========================================\n');
+}
+runStorageTest().catch(err => {
+    console.error('Test failed:', err);
+    process.exit(1);
+});