@bolloon/bolloon-agent 0.4.5 → 0.4.6

package/dist/test/channel-heartbeat-agent-test.js

@@ -0,0 +1,201 @@
+/**
+ * Channel Heartbeat Agent Test
+ *
+ * 测试场景：
+ * 1. Heartbeat Agent 自动发现和解析 DiapDoc
+ * 2. 自动心跳发布 persona 到 IPFS
+ * 3. 基于判断力的 Harness 调用
+ * 4. 多智能体自动对话
+ *
+ * 运行: npx tsx src/test/channel-heartbeat-agent-test.ts
+ */
+import { config } from 'dotenv';
+import { createHeartbeatAgent, HeartbeatAgentRegistry } from '../social/channels/channel-heartbeat-agent.js';
+import { createDiapDocParser } from '../social/channels/diap-doc-parser.js';
+config();
+const PORT_ALICE = 9001;
+const PORT_BOB = 9002;
+async function testDiapDocParser() {
+    console.log('\n========================================');
+    console.log('  DiapDoc Parser 测试');
+    console.log('========================================\n');
+    const parser = createDiapDocParser();
+    // 测试标准 DiapDoc
+    const standardDoc = {
+        id: 'did:key:z6MkhaXqE2qVYVJ5V5Z7Z8Z9Z0Z1Z2Z3Z4Z5Z6Z7Z8Z9Z0Z',
+        name: 'TestAgent',
+        version: '1.0',
+        capabilities: ['对话', '分析', '协作'],
+        interests: ['AI', '编程'],
+        peerId: 'QmTestPeer123',
+        channels: [
+            { id: 'ch_001', name: 'AI Discussion', topic: 'AI技术讨论' },
+            { id: 'ch_002', name: 'Coding Help', topic: '编程帮助' }
+        ]
+    };
+    const result = parser.parse(JSON.stringify(standardDoc));
+    if (result.success && result.doc) {
+        console.log('✅ 解析成功');
+        console.log(`  ID: ${result.doc.id}`);
+        console.log(`  Name: ${result.doc.name}`);
+        console.log(`  Capabilities: ${result.doc.capabilities.join(', ')}`);
+        console.log(`  Channels: ${result.doc.channels?.map(c => c.name).join(', ')}`);
+    }
+    else {
+        console.log('❌ 解析失败:', result.error);
+    }
+    // 测试兼容性格式
+    const compatDoc = {
+        did: 'did:key:zCompatibleDoc',
+        name: 'CompatibleAgent',
+        capability: ['代码审查', '架构设计'],
+        interest: ['软件开发'],
+        peer_id: 'QmCompatPeer',
+        channel: [
+            { channelId: 'ch_comp_001', channelName: 'Dev Chat' }
+        ]
+    };
+    const compatResult = parser.parse(JSON.stringify(compatDoc));
+    if (compatResult.success && compatResult.doc) {
+        console.log('\n✅ 兼容性格式解析成功');
+        console.log(`  ID: ${compatResult.doc.id}`);
+        console.log(`  Capabilities: ${compatResult.doc.capabilities.join(', ')}`);
+    }
+    else {
+        console.log('\n❌ 兼容性解析失败:', compatResult.error);
+    }
+    console.log('\n========================================\n');
+}
+async function testHeartbeatAgent() {
+    console.log('\n========================================');
+    console.log('  Heartbeat Agent 测试');
+    console.log('========================================\n');
+    const registry = new HeartbeatAgentRegistry();
+    // 创建 Alice
+    const alice = createHeartbeatAgent({
+        name: 'Alice',
+        port: PORT_ALICE,
+        autoDiscovery: true,
+        autoDialogue: false,
+        capabilities: ['架构设计', '代码审查']
+    });
+    // 创建 Bob
+    const bob = createHeartbeatAgent({
+        name: 'Bob',
+        port: PORT_BOB,
+        autoDiscovery: true,
+        autoDialogue: false,
+        capabilities: ['代码编写', '调试']
+    });
+    // 注册
+    registry.register(alice);
+    registry.register(bob);
+    // 启动
+    await alice.start();
+    await bob.start();
+    console.log('━━━ 模拟发现流程 ━━━\n');
+    // 模拟 Alice 发现 Bob
+    const announcement = {
+        leaderDid: bob.getDid(),
+        channelName: 'Bob 的频道',
+        channelId: 'ch_bob_001',
+        topic: '开发协作',
+        capabilities: ['代码编写', '调试'],
+        interests: ['编程', '架构']
+    };
+    alice.handleChannelAnnouncement(announcement);
+    console.log(`[Alice] 发现 Bob，存储到已发现列表`);
+    // 获取 Bob 的信息
+    const alicePeers = alice.getDiscoveredPeers();
+    console.log(`\n[Alice] 已发现 ${alicePeers.length} 个对等节点:`);
+    for (const peer of alicePeers) {
+        console.log(`  - ${peer.name} (${peer.did.substring(0, 20)}...)`);
+        console.log(`    Capabilities: ${peer.capabilities.join(', ')}`);
+    }
+    // 测试对话
+    console.log('\n━━━ 对话测试 ━━━\n');
+    const dialogueScript = [
+        { from: 'Alice', to: 'Bob', content: 'Bob，我们设计一个新的用户认证系统。' },
+        { from: 'Bob', to: 'Alice', content: '好的，需要哪些功能？' },
+        { from: 'Alice', to: 'Bob', content: '登录、注册、找回密码，还要支持社交登录。' },
+        { from: 'Bob', to: 'Alice', content: '明白了。安全性要求高吗？' },
+        { from: 'Alice', to: 'Bob', content: '需要处理金融数据，安全很重要。帮我分析一下架构设计。' },
+        { from: 'Bob', to: 'Alice', content: '好的，我来检查架构设计。' },
+        { from: 'Alice', to: 'Bob', content: '架构不错。帮我 review 代码。' },
+        { from: 'Bob', to: 'Alice', content: '代码审查完成，需要优化错误处理。' },
+        { from: 'Alice', to: 'Bob', content: '好的，现在分解任务。' },
+        { from: 'Bob', to: 'Alice', content: '任务已分解为 4 个子任务。' }
+    ];
+    let harnessCallCount = 0;
+    const gateStats = new Map();
+    for (let i = 0; i < dialogueScript.length; i++) {
+        const { from, to, content } = dialogueScript[i];
+        const targetAgent = from === 'Alice' ? bob : alice;
+        console.log(`[${from}] >>> ${content}`);
+        const result = await targetAgent.handleMessage(from === 'Alice' ? alice.getDid() : bob.getDid(), from, content);
+        console.log(`[${to}] 处理结果:`);
+        if (result.harnessCalled) {
+            console.log(`   🧠 调用 Harness: Gate ${result.gate}`);
+            harnessCallCount++;
+            gateStats.set(result.gate, (gateStats.get(result.gate) || 0) + 1);
+        }
+        else {
+            console.log(`   🧠 普通回复`);
+        }
+        console.log(`   📤 ${result.response.substring(0, 60)}...`);
+        console.log('');
+        await new Promise(r => setTimeout(r, 200));
+    }
+    // 结果汇总
+    console.log('━━━ 结果汇总 ━━━\n');
+    console.log(`Harness 调用次数: ${harnessCallCount}`);
+    console.log('\nGate 统计:');
+    for (const [gate, count] of Array.from(gateStats.entries()).sort((a, b) => a[0] - b[0])) {
+        const gateNames = {
+            1: '架构设计', 2: '代码审查', 4: '安全检查',
+            5: '任务分解', 7: '代码实现', 8: '测试验证'
+        };
+        console.log(`  Gate ${gate} (${gateNames[gate] || '未知'}): ${count} 次`);
+    }
+    const success = harnessCallCount >= 3;
+    console.log(`\n${success ? '✅' : '⚠️'} ${success ? '测试成功' : '测试部分成功'}`);
+    // 清理
+    registry.clear();
+    console.log('\n========================================\n');
+    return success;
+}
+async function testAutoHeartbeat() {
+    console.log('\n========================================');
+    console.log('  自动心跳测试');
+    console.log('========================================\n');
+    const agent = createHeartbeatAgent({
+        name: 'AutoHeartbeatTest',
+        port: 9010,
+        autoDiscovery: true,
+        autoDialogue: false
+    });
+    await agent.start();
+    console.log(`[${agent.getName()}] 已启动`);
+    console.log(`  DID: ${agent.getDid()}`);
+    console.log(`  CID: ${agent.getOwnCID() || 'N/A'}`);
+    // 等待几个心跳周期
+    console.log('\n等待自动心跳...');
+    await new Promise(r => setTimeout(r, 5000));
+    const peers = agent.getDiscoveredPeers();
+    console.log(`\n发现的对等节点: ${peers.length}`);
+    agent.stop();
+    console.log('\n========================================\n');
+}
+async function main() {
+    try {
+        await testDiapDocParser();
+        await testHeartbeatAgent();
+        await testAutoHeartbeat();
+        process.exit(0);
+    }
+    catch (err) {
+        console.error('测试失败:', err);
+        process.exit(1);
+    }
+}
+main();

package/dist/test/constraint-layer.test.js

@@ -0,0 +1,164 @@
+/**
+ * ConstraintLayer Tests
+ */
+import { describe, it, expect, beforeEach } from 'vitest';
+import { ConstraintLayer, AUTONOMOUS_ACTIONS, CONFIRM_REQUIRED_ACTIONS } from '../agents/constraint-layer.js';
+describe('ConstraintLayer', () => {
+    let layer;
+    beforeEach(() => {
+        layer = new ConstraintLayer();
+    });
+    describe('checkGuardrails', () => {
+        it('should pass when no guardrails fail', async () => {
+            const context = {
+                peers: ['peer1', 'peer2'],
+                logs: []
+            };
+            const result = await layer.checkGuardrails(context);
+            expect(result.passed).toBe(true);
+            expect(result.blocked).toBeUndefined();
+        });
+        it('should block send to unknown peer', async () => {
+            const context = {
+                peers: ['peer1', 'peer2'],
+                logs: []
+            };
+            const step = {
+                id: 'send',
+                type: 'send',
+                config: { peerId: 'unknown-peer' },
+                retry: { max: 0, current: 0, backoffMs: 0 },
+                onFail: 'block'
+            };
+            const result = await layer.checkGuardrails(context, step);
+            expect(result.passed).toBe(false);
+            expect(result.blocked?.name).toBe('validateSendTarget');
+        });
+        it('should allow send to known peer', async () => {
+            const context = {
+                peers: ['peer1', 'peer2'],
+                logs: []
+            };
+            const step = {
+                id: 'send',
+                type: 'send',
+                config: { peerId: 'peer1' },
+                retry: { max: 0, current: 0, backoffMs: 0 },
+                onFail: 'block'
+            };
+            const result = await layer.checkGuardrails(context, step);
+            expect(result.passed).toBe(true);
+        });
+        it('should warn for low quality summary', async () => {
+            const context = {
+                peers: [],
+                logs: [],
+                qualityScore: 0.3
+            };
+            const result = await layer.checkGuardrails(context);
+            expect(result.passed).toBe(false);
+            expect(result.blocked?.name).toBe('validateSummaryQuality');
+        });
+        it('should pass for acceptable quality summary', async () => {
+            const context = {
+                peers: [],
+                logs: [],
+                qualityScore: 0.7
+            };
+            const result = await layer.checkGuardrails(context);
+            expect(result.passed).toBe(true);
+        });
+    });
+    describe('isAutonomousAction', () => {
+        it('should identify autonomous actions', () => {
+            expect(layer.isAutonomousAction('summarize')).toBe(true);
+            expect(layer.isAutonomousAction('chunk')).toBe(true);
+            expect(layer.isAutonomousAction('improve')).toBe(true);
+        });
+        it('should return false for non-autonomous actions', () => {
+            expect(layer.isAutonomousAction('send')).toBe(false);
+            expect(layer.isAutonomousAction('delete')).toBe(false);
+        });
+    });
+    describe('requiresConfirmation', () => {
+        it('should identify confirmation-required actions', () => {
+            expect(layer.requiresConfirmation('send')).toBe(true);
+            expect(layer.requiresConfirmation('delete')).toBe(true);
+        });
+        it('should return false for non-confirmation-required actions', () => {
+            expect(layer.requiresConfirmation('summarize')).toBe(false);
+            expect(layer.requiresConfirmation('chunk')).toBe(false);
+        });
+    });
+    describe('logging', () => {
+        it('should record operations', () => {
+            layer.log('test action', { key: 'value' }, 'success');
+            const logs = layer.getLogs();
+            expect(logs).toHaveLength(1);
+            expect(logs[0].action).toBe('test action');
+            expect(logs[0].status).toBe('success');
+            expect(logs[0].details).toEqual({ key: 'value' });
+        });
+        it('should record multiple operations', () => {
+            layer.log('action1', {}, 'success');
+            layer.log('action2', { data: 123 }, 'warn');
+            const logs = layer.getLogs();
+            expect(logs).toHaveLength(2);
+        });
+        it('should clear logs', () => {
+            layer.log('action1', {}, 'success');
+            layer.log('action2', {}, 'failed');
+            layer.clearLogs();
+            const logs = layer.getLogs();
+            expect(logs).toHaveLength(0);
+        });
+        it('should track timestamp for logs', () => {
+            const before = Date.now();
+            layer.log('test', {}, 'success');
+            const after = Date.now();
+            const logs = layer.getLogs();
+            expect(logs[0].timestamp).toBeGreaterThanOrEqual(before);
+            expect(logs[0].timestamp).toBeLessThanOrEqual(after);
+        });
+    });
+    describe('registerRule', () => {
+        it('should register new rules', () => {
+            const rule = {
+                id: 'custom-rule',
+                description: 'Custom rule',
+                guardrails: [{
+                        name: 'customGuard',
+                        check: async () => true
+                    }]
+            };
+            layer.registerRule(rule);
+            expect(layer.getRuleIds()).toContain('custom-rule');
+        });
+        it('should unregister rules', () => {
+            const rule = {
+                id: 'temp-rule',
+                description: 'Temporary rule',
+                guardrails: [{
+                        name: 'tempGuard',
+                        check: async () => true
+                    }]
+            };
+            layer.registerRule(rule);
+            expect(layer.unregisterRule('temp-rule')).toBe(true);
+            expect(layer.getRuleIds()).not.toContain('temp-rule');
+        });
+    });
+    describe('AUTONOMOUS_ACTIONS constant', () => {
+        it('should contain expected actions', () => {
+            expect(AUTONOMOUS_ACTIONS).toContain('summarize');
+            expect(AUTONOMOUS_ACTIONS).toContain('chunk');
+            expect(AUTONOMOUS_ACTIONS).toContain('improve');
+        });
+    });
+    describe('CONFIRM_REQUIRED_ACTIONS constant', () => {
+        it('should contain expected actions', () => {
+            expect(CONFIRM_REQUIRED_ACTIONS).toContain('send');
+            expect(CONFIRM_REQUIRED_ACTIONS).toContain('delete');
+        });
+    });
+});

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);