@bolloon/bolloon-agent 0.2.9 → 0.2.11

package/dist/test/diap-identity-test.js

@@ -0,0 +1,172 @@
+/**
+ * DIAP Identity Test - 测试 DIAP 身份生成和 DID 注册
+ *
+ * 测试内容：
+ * 1. 生成 DIAP 身份 (KeyManager)
+ * 2. 创建 DID 文档
+ * 3. 模拟发布到 IPFS（不依赖真实 IPFS）
+ * 4. 模拟从 IPFS 解析 DID 文档
+ *
+ * 运行: npx tsx src/test/diap-identity-test.ts
+ */
+import { KeyManager } from '@diap/sdk';
+async function main() {
+    console.log('\n╔═══════════════════════════════════════════════════════╗');
+    console.log('║         DIAP Identity Test - 身份生成与 DID 注册       ║');
+    console.log('╚═══════════════════════════════════════════════════════╝\n');
+    // ============================================================
+    // 测试 1: 生成 DIAP 身份
+    // ============================================================
+    console.log('[Test 1/4] 生成 DIAP 身份...');
+    console.log('─'.repeat(50));
+    const keyManager = KeyManager.generate();
+    const did = keyManager.did;
+    const publicKeyHex = Buffer.from(keyManager.publicKey).toString('hex');
+    console.log(`  ✅ DID 生成成功`);
+    console.log(`     DID: ${did}`);
+    console.log(`     公钥: ${publicKeyHex.substring(0, 32)}...`);
+    // 提取用户名
+    const username = process.env.USER || process.env.USERNAME || 'mechrevo';
+    const didSuffix = did.split(':').pop() || '';
+    const shortSuffix = didSuffix.substring(0, Math.min(4, didSuffix.length));
+    const agentName = `blln-${username.toLowerCase()}-${shortSuffix}`;
+    console.log(`     名称: ${agentName}`);
+    // ============================================================
+    // 测试 2: 创建 DID 文档
+    // ============================================================
+    console.log('\n[Test 2/4] 创建 DID 文档...');
+    console.log('─'.repeat(50));
+    const diapDoc = {
+        id: did,
+        name: agentName,
+        version: '1.0',
+        capabilities: ['chat', 'reasoning', 'judgment-injection', 'harness-workflow'],
+        interests: ['ai', 'p2p', 'judgment-system'],
+        publicKey: publicKeyHex,
+        channels: [
+            { id: `ch_${Date.now()}`, name: '主对话' }
+        ],
+        createdAt: new Date().toISOString(),
+        updatedAt: new Date().toISOString()
+    };
+    const docJson = JSON.stringify(diapDoc, null, 2);
+    console.log(`  ✅ DID 文档创建成功`);
+    console.log(`     文档大小: ${docJson.length} 字节`);
+    console.log(`     能力列表: ${diapDoc.capabilities.join(', ')}`);
+    console.log(`     兴趣领域: ${diapDoc.interests.join(', ')}`);
+    // ============================================================
+    // 测试 3: 模拟发布到 IPFS
+    // ============================================================
+    console.log('\n[Test 3/4] 模拟发布到 IPFS...');
+    console.log('─'.repeat(50));
+    // 模拟 IPFS CID 生成（使用 DID 的哈希）
+    const crypto = await import('crypto');
+    const docHash = crypto.createHash('sha256').update(docJson).digest('base64url');
+    const simulatedCid = `baf${docHash.substring(0, 50)}`;
+    console.log(`  ✅ 模拟 IPFS 发布成功`);
+    console.log(`     模拟 CID: ${simulatedCid}`);
+    // 测试 AgentAuthManager（需要真实 IPFS）
+    console.log('\n  📡 尝试连接真实 IPFS...');
+    try {
+        const { AgentAuthManager } = await import('@diap/sdk');
+        const authManager = await AgentAuthManager.newWithRemoteIpfs('http://127.0.0.1:5001', 'http://127.0.0.1:8080');
+        const result = await authManager.registerAgent({ name: agentName, services: [] }, keyManager, '');
+        console.log(`  ✅ 真实 IPFS 注册成功`);
+        console.log(`     CID: ${result.cid || 'N/A'}`);
+        console.log(`     IPNS: ${result.ipnsName || 'N/A'}`);
+        return {
+            did,
+            agentName,
+            publicKey: publicKeyHex,
+            diapDoc,
+            cid: result.cid || simulatedCid,
+            ipnsName: result.ipnsName
+        };
+    }
+    catch (e) {
+        const error = e;
+        console.log(`  ⚠️  真实 IPFS 不可用: ${error.message}`);
+        console.log('     将使用模拟数据继续测试');
+        return {
+            did,
+            agentName,
+            publicKey: publicKeyHex,
+            diapDoc,
+            cid: simulatedCid,
+            ipnsName: null
+        };
+    }
+}
+async function testParseDID(doc, cid) {
+    // ============================================================
+    // 测试 4: 解析 DID 文档
+    // ============================================================
+    console.log('\n[Test 4/4] 解析 DID 文档...');
+    console.log('─'.repeat(50));
+    // 从 IPFS 获取内容
+    console.log('  📡 从 IPFS 解析...');
+    // 方式1: 使用 IpfsClient
+    try {
+        const { IpfsClient } = await import('@diap/sdk');
+        const ipfs = new IpfsClient('http://127.0.0.1:5001', null);
+        console.log(`     尝试从 CID ${cid} 获取...`);
+        const content = await ipfs.get(cid);
+        const parsedDoc = JSON.parse(content);
+        console.log(`  ✅ IpfsClient 解析成功`);
+        console.log(`     DID: ${parsedDoc.id}`);
+        console.log(`     创建时间: ${parsedDoc.created}`);
+        return;
+    }
+    catch (e) {
+        console.log(`  ⚠️  IpfsClient 解析失败: ${e.message}`);
+    }
+    // 方式2: 直接使用 fetch
+    console.log('  📡 尝试直接使用 fetch...');
+    try {
+        const response = await fetch(`http://127.0.0.1:5001/api/v0/cat?arg=${cid}`, {
+            method: 'POST'
+        });
+        const text = await response.text();
+        const parsedDoc = JSON.parse(text);
+        console.log(`  ✅ 直接 fetch 解析成功`);
+        console.log(`     DID: ${parsedDoc.id}`);
+        console.log(`     验证方法数: ${parsedDoc.verificationMethod?.length || 0}`);
+        if (parsedDoc.service) {
+            console.log(`     服务端点数: ${parsedDoc.service.length}`);
+        }
+        return;
+    }
+    catch (e) {
+        console.log(`  ⚠️  直接 fetch 解析失败: ${e.message}`);
+    }
+    // 方式3: 使用本地文档模拟
+    console.log(`  ⚠️  使用本地文档模拟解析结果`);
+    console.log(`  ✅ 本地解析成功`);
+    console.log(`     DID: ${doc.id}`);
+    console.log(`     名称: ${doc.name}`);
+    console.log(`     公钥: ${doc.publicKey.substring(0, 32)}...`);
+    console.log(`     能力: ${doc.capabilities.join(', ')}`);
+    console.log(`     频道: ${doc.channels?.map(c => c.name).join(', ')}`);
+}
+// 运行测试
+(async () => {
+    try {
+        const result = await main();
+        console.log('\n' + '═'.repeat(50));
+        console.log('  测试结果摘要');
+        console.log('═'.repeat(50));
+        console.log(`  DID: ${result.did}`);
+        console.log(`  名称: ${result.agentName}`);
+        console.log(`  CID: ${result.cid}`);
+        if (result.ipnsName) {
+            console.log(`  IPNS: ${result.ipnsName}`);
+        }
+        console.log('═'.repeat(50));
+        await testParseDID(result.diapDoc, result.cid);
+        console.log('\n✅ 所有测试完成！\n');
+    }
+    catch (e) {
+        console.error('\n❌ 测试失败:', e.message);
+        process.exit(1);
+    }
+})();

package/dist/test/diap-quick-test.js

@@ -0,0 +1,62 @@
+/**
+ * DIAP Quick Test - 快速验证 DIAP 功能（跳过慢速 IPNS）
+ */
+import { KeyManager } from '@diap/sdk';
+async function main() {
+    console.log('\n🔑 DIAP 快速验证测试\n');
+    // 1. 生成身份
+    console.log('[1] 生成 DIAP 身份...');
+    const km = KeyManager.generate();
+    console.log(`    ✅ DID: ${km.did}`);
+    // 2. 验证可以直接获取公钥
+    console.log('\n[2] 获取公钥...');
+    const pkHex = Buffer.from(km.publicKey).toString('hex');
+    console.log(`    ✅ 公钥: ${pkHex.substring(0, 24)}...`);
+    // 3. 测试本地 IPFS
+    console.log('\n[3] 测试本地 IPFS...');
+    const testContent = JSON.stringify({
+        test: true,
+        did: km.did,
+        timestamp: Date.now()
+    });
+    try {
+        // 上传 - 使用 form-data 格式
+        const formData = new FormData();
+        const blob = new Blob([testContent], { type: 'application/json' });
+        formData.append('file', blob, 'test.json');
+        const addResponse = await fetch('http://127.0.0.1:5001/api/v0/add', {
+            method: 'POST',
+            body: formData
+        });
+        const addResult = await addResponse.text();
+        // IPFS add 返回格式: {"Name":"test.json","Hash":"Qm...","Size":"..."}
+        const cidMatch = addResult.match(/"Hash":"([^"]+)"/);
+        const cid = cidMatch ? cidMatch[1] : null;
+        if (!cid) {
+            console.log(`    ⚠️  解析 CID 失败: ${addResult}`);
+            throw new Error('CID not found');
+        }
+        console.log(`    ✅ 上传成功: ${cid}`);
+        // 下载
+        const getResponse = await fetch(`http://127.0.0.1:5001/api/v0/cat?arg=${cid}`, {
+            method: 'POST'
+        });
+        const retrieved = await getResponse.text();
+        const parsed = JSON.parse(retrieved);
+        console.log(`    ✅ 下载成功: test=${parsed.test}`);
+        console.log('\n═══════════════════════════════════════');
+        console.log('  ✅ DIAP + IPFS 基本功能正常！');
+        console.log('═══════════════════════════════════════');
+        console.log(`\n  本节点信息:`);
+        console.log(`  · DID: ${km.did}`);
+        console.log(`  · CID: ${cid}`);
+        console.log(`\n  供另一台电脑使用的连接信息:`);
+        console.log(`  · DID: ${km.did}`);
+        console.log(`  · CID: ${cid}`);
+        console.log('');
+    }
+    catch (e) {
+        console.log(`    ❌ IPFS 操作失败: ${e.message}`);
+    }
+}
+main().catch(console.error);

package/dist/test/global-shared-context.test.js

@@ -0,0 +1,315 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import { GlobalSharedContextManager, resetGlobalSharedContext } from '../social/global-shared-context.js';
+const TEST_CONTEXT_PATH = path.join('/tmp', '.bolloon-test', 'sessions', 'test-global-context.json');
+describe('GlobalSharedContext', () => {
+    let contextManager;
+    beforeEach(async () => {
+        resetGlobalSharedContext();
+        contextManager = new GlobalSharedContextManager(TEST_CONTEXT_PATH);
+        try {
+            await fs.rm(path.dirname(TEST_CONTEXT_PATH), { recursive: true, force: true });
+        }
+        catch { }
+    });
+    describe('SharedMemory - recentActions', () => {
+        it('should add user action', async () => {
+            await contextManager.initialize();
+            await contextManager.addUserAction('用户要求总结文档', 'agent1', 'channel1', 8);
+            const actions = await contextManager.getRecentActions();
+            expect(actions).toHaveLength(1);
+            expect(actions[0].content).toBe('用户要求总结文档');
+            expect(actions[0].agentId).toBe('agent1');
+            expect(actions[0].channelId).toBe('channel1');
+            expect(actions[0].importance).toBe(8);
+        });
+        it('should limit recent actions to 50', async () => {
+            await contextManager.initialize();
+            for (let i = 0; i < 60; i++) {
+                await contextManager.addUserAction(`Action ${i}`);
+            }
+            const actions = await contextManager.getRecentActions(60);
+            expect(actions).toHaveLength(50);
+        });
+        it('should return formatted summary', async () => {
+            await contextManager.initialize();
+            await contextManager.addUserAction('测试行动1');
+            await contextManager.addUserAction('测试行动2');
+            const summary = await contextManager.getRecentActionsSummary(10);
+            expect(summary).toContain('测试行动1');
+            expect(summary).toContain('测试行动2');
+        });
+    });
+    describe('SharedMemory - sharedKnowledge', () => {
+        it('should add shared knowledge', async () => {
+            await contextManager.initialize();
+            await contextManager.addSharedKnowledge('这是一个重要的跨Agent共享知识');
+            const knowledge = await contextManager.getSharedKnowledge();
+            expect(knowledge).toContain('这是一个重要的跨Agent共享知识');
+        });
+        it('should not duplicate knowledge', async () => {
+            await contextManager.initialize();
+            await contextManager.addSharedKnowledge('共享知识');
+            await contextManager.addSharedKnowledge('共享知识');
+            const knowledge = await contextManager.getSharedKnowledge();
+            expect(knowledge.filter(k => k === '共享知识')).toHaveLength(1);
+        });
+        it('should limit shared knowledge to 100', async () => {
+            await contextManager.initialize();
+            for (let i = 0; i < 110; i++) {
+                await contextManager.addSharedKnowledge(`Knowledge ${i}`);
+            }
+            const knowledge = await contextManager.getSharedKnowledge();
+            expect(knowledge).toHaveLength(100);
+        });
+    });
+    describe('SharedMemory - currentTask', () => {
+        it('should set and get current task', async () => {
+            await contextManager.initialize();
+            const task = await contextManager.setCurrentTask({
+                description: '完成文档总结',
+                status: 'in_progress'
+            });
+            expect(task.id).toBeDefined();
+            expect(task.description).toBe('完成文档总结');
+            expect(task.status).toBe('in_progress');
+            expect(task.createdAt).toBeDefined();
+            const currentTask = await contextManager.getCurrentTask();
+            expect(currentTask?.description).toBe('完成文档总结');
+        });
+        it('should complete current task', async () => {
+            await contextManager.initialize();
+            await contextManager.setCurrentTask({
+                description: '完成文档总结',
+                status: 'in_progress'
+            });
+            await contextManager.completeCurrentTask('文档总结已完成');
+            const currentTask = await contextManager.getCurrentTask();
+            expect(currentTask?.status).toBe('completed');
+            expect(currentTask?.result).toBe('文档总结已完成');
+            expect(currentTask?.completedAt).toBeDefined();
+        });
+    });
+    describe('AgentRegistry', () => {
+        it('should register agent', async () => {
+            await contextManager.initialize();
+            await contextManager.registerAgent({
+                agentId: 'agent-001',
+                sessionId: 'session-001',
+                channelId: 'channel-001',
+                capabilities: ['coding', 'writing'],
+                status: 'active',
+                name: 'TestAgent'
+            });
+            const agent = await contextManager.getAgent('agent-001');
+            expect(agent).toBeDefined();
+            expect(agent?.name).toBe('TestAgent');
+            expect(agent?.capabilities).toEqual(['coding', 'writing']);
+            expect(agent?.status).toBe('active');
+        });
+        it('should update agent status', async () => {
+            await contextManager.initialize();
+            await contextManager.registerAgent({
+                agentId: 'agent-001',
+                sessionId: 'session-001',
+                channelId: 'channel-001',
+                capabilities: ['coding'],
+                status: 'active'
+            });
+            await contextManager.updateAgentStatus('agent-001', 'busy');
+            const agent = await contextManager.getAgent('agent-001');
+            expect(agent?.status).toBe('busy');
+        });
+        it('should get all agents', async () => {
+            await contextManager.initialize();
+            await contextManager.registerAgent({
+                agentId: 'agent-001',
+                sessionId: 'session-001',
+                channelId: 'channel-001',
+                capabilities: ['coding'],
+                status: 'active'
+            });
+            await contextManager.registerAgent({
+                agentId: 'agent-002',
+                sessionId: 'session-002',
+                channelId: 'channel-002',
+                capabilities: ['writing'],
+                status: 'idle'
+            });
+            const agents = await contextManager.getAllAgents();
+            expect(agents).toHaveLength(2);
+        });
+        it('should find agents by capability', async () => {
+            await contextManager.initialize();
+            await contextManager.registerAgent({
+                agentId: 'agent-001',
+                sessionId: 'session-001',
+                channelId: 'channel-001',
+                capabilities: ['coding', 'debugging'],
+                status: 'active'
+            });
+            await contextManager.registerAgent({
+                agentId: 'agent-002',
+                sessionId: 'session-002',
+                channelId: 'channel-002',
+                capabilities: ['writing', 'editing'],
+                status: 'active'
+            });
+            const codingAgents = await contextManager.findAgentByCapability('coding');
+            expect(codingAgents).toHaveLength(1);
+            expect(codingAgents[0].agentId).toBe('agent-001');
+        });
+        it('should get active agents', async () => {
+            await contextManager.initialize();
+            await contextManager.registerAgent({
+                agentId: 'agent-001',
+                sessionId: 'session-001',
+                channelId: 'channel-001',
+                capabilities: ['coding'],
+                status: 'active'
+            });
+            await contextManager.registerAgent({
+                agentId: 'agent-002',
+                sessionId: 'session-002',
+                channelId: 'channel-002',
+                capabilities: ['writing'],
+                status: 'idle'
+            });
+            const activeAgents = await contextManager.getActiveAgents();
+            expect(activeAgents).toHaveLength(1);
+            expect(activeAgents[0].agentId).toBe('agent-001');
+        });
+        it('should unregister agent', async () => {
+            await contextManager.initialize();
+            await contextManager.registerAgent({
+                agentId: 'agent-001',
+                sessionId: 'session-001',
+                channelId: 'channel-001',
+                capabilities: ['coding'],
+                status: 'active'
+            });
+            await contextManager.unregisterAgent('agent-001');
+            const agent = await contextManager.getAgent('agent-001');
+            expect(agent).toBeUndefined();
+        });
+    });
+    describe('CooperationQueue', () => {
+        it('should create cooperation task', async () => {
+            await contextManager.initialize();
+            const cooperation = await contextManager.createCooperation('consult', 'agent-001', '请帮我分析这段代码', 'agent-002', 'context here');
+            expect(cooperation.id).toBeDefined();
+            expect(cooperation.type).toBe('consult');
+            expect(cooperation.fromAgentId).toBe('agent-001');
+            expect(cooperation.toAgentId).toBe('agent-002');
+            expect(cooperation.task).toBe('请帮我分析这段代码');
+            expect(cooperation.context).toBe('context here');
+            expect(cooperation.status).toBe('pending');
+        });
+        it('should update cooperation status', async () => {
+            await contextManager.initialize();
+            const cooperation = await contextManager.createCooperation('delegate', 'agent-001', '完成这个任务');
+            await contextManager.updateCooperationStatus(cooperation.id, 'in_progress');
+            const updated = await contextManager.getCooperation(cooperation.id);
+            expect(updated?.status).toBe('in_progress');
+        });
+        it('should get pending cooperations for agent', async () => {
+            await contextManager.initialize();
+            await contextManager.createCooperation('consult', 'agent-001', 'Task 1', 'agent-002');
+            await contextManager.createCooperation('delegate', 'agent-001', 'Task 2');
+            const pending = await contextManager.getPendingCooperations('agent-001');
+            expect(pending).toHaveLength(2);
+        });
+        it('should get cooperations for specific agent', async () => {
+            await contextManager.initialize();
+            await contextManager.createCooperation('consult', 'agent-001', 'Task for agent-002', 'agent-002');
+            await contextManager.createCooperation('delegate', 'agent-003', 'Task for agent-003', 'agent-003');
+            const agent002Coops = await contextManager.getCooperationsForAgent('agent-002');
+            expect(agent002Coops).toHaveLength(1);
+            expect(agent002Coops[0].task).toBe('Task for agent-002');
+        });
+        it('should add result to cooperation', async () => {
+            await contextManager.initialize();
+            const cooperation = await contextManager.createCooperation('consult', 'agent-001', '请分析');
+            await contextManager.updateCooperationStatus(cooperation.id, 'done', '分析结果：代码有bug');
+            const updated = await contextManager.getCooperation(cooperation.id);
+            expect(updated?.status).toBe('done');
+            expect(updated?.result).toBe('分析结果：代码有bug');
+        });
+    });
+    describe('Full context', () => {
+        it('should get full context', async () => {
+            await contextManager.initialize();
+            await contextManager.addUserAction('Test action');
+            await contextManager.addSharedKnowledge('Test knowledge');
+            await contextManager.registerAgent({
+                agentId: 'agent-001',
+                sessionId: 'session-001',
+                channelId: 'channel-001',
+                capabilities: ['coding'],
+                status: 'active'
+            });
+            const fullContext = await contextManager.getFullContext();
+            expect(fullContext.memory.recentActions).toHaveLength(1);
+            expect(fullContext.memory.sharedKnowledge).toHaveLength(1);
+            expect(fullContext.agentRegistry['agent-001']).toBeDefined();
+        });
+        it('should get context summary', async () => {
+            await contextManager.initialize();
+            await contextManager.addUserAction('用户执行了操作A');
+            await contextManager.registerAgent({
+                agentId: 'agent-001',
+                sessionId: 'session-001',
+                channelId: 'channel-001',
+                capabilities: ['coding'],
+                status: 'active',
+                name: '编码助手'
+            });
+            const summary = await contextManager.getContextSummary();
+            expect(summary).toContain('全局共享上下文');
+            expect(summary).toContain('最近行动');
+            expect(summary).toContain('用户执行了操作A');
+            expect(summary).toContain('Agent 注册');
+            expect(summary).toContain('编码助手');
+        });
+    });
+    describe('Persistence', () => {
+        it('should persist and reload context', async () => {
+            await contextManager.initialize();
+            await contextManager.addUserAction('持久化测试');
+            await contextManager.registerAgent({
+                agentId: 'agent-001',
+                sessionId: 'session-001',
+                channelId: 'channel-001',
+                capabilities: ['coding'],
+                status: 'active'
+            });
+            const newManager = new GlobalSharedContextManager(TEST_CONTEXT_PATH);
+            await newManager.initialize();
+            const actions = await newManager.getRecentActions();
+            expect(actions).toHaveLength(1);
+            expect(actions[0].content).toBe('持久化测试');
+            const agent = await newManager.getAgent('agent-001');
+            expect(agent).toBeDefined();
+        });
+    });
+    describe('Clear', () => {
+        it('should clear all data', async () => {
+            await contextManager.initialize();
+            await contextManager.addUserAction('Test action');
+            await contextManager.addSharedKnowledge('Test knowledge');
+            await contextManager.registerAgent({
+                agentId: 'agent-001',
+                sessionId: 'session-001',
+                channelId: 'channel-001',
+                capabilities: ['coding'],
+                status: 'active'
+            });
+            await contextManager.clear();
+            const context = await contextManager.getFullContext();
+            expect(context.memory.recentActions).toHaveLength(0);
+            expect(context.memory.sharedKnowledge).toHaveLength(0);
+            expect(Object.keys(context.agentRegistry)).toHaveLength(0);
+        });
+    });
+});