@bolloon/bolloon-agent 0.4.5 → 0.4.6

package/dist/test/iroh-communication.test.js

@@ -0,0 +1,66 @@
+import { irohTransport } from '../network/iroh-transport.js';
+async function testTwoNodesCommunication() {
+    console.log('=== Two Node Communication Test ===\n');
+    // 启动第一个节点 (server)
+    console.log('[Node1] Starting...');
+    const node1 = await irohTransport.start();
+    console.log('[Node1] Node ID:', node1.nodeId.substring(0, 16) + '...');
+    console.log('[Node1] Addr:', node1.addr.substring(0, 32) + '...\n');
+    // 注册消息处理器
+    let messageCount = 0;
+    const messages = [];
+    irohTransport.onMessage('hello', (msg) => {
+        messageCount++;
+        messages.push(msg);
+        console.log(`[Node1] Received message #${messageCount} from ${msg.from.substring(0, 8)}...`);
+        console.log(`[Node1] Payload: ${new TextDecoder().decode(msg.payload)}`);
+    });
+    // 模拟第二个节点连接并发送消息
+    // 注意: 在实际场景中，两个节点需要在不同进程/机器上运行
+    // 这里我们测试的是单节点的消息处理能力
+    console.log('[Node1] Listening for incoming connections...\n');
+    // 等待一段时间看是否有连接
+    await new Promise(resolve => setTimeout(resolve, 2000));
+    console.log(`[Node1] Messages received: ${messageCount}`);
+    // 测试发送消息 API (模拟)
+    console.log('\n[Node1] Testing sendMessage API...');
+    const fakeTargetId = 'c0b07356bcf4a505000000000000000000000000';
+    // 注意: 这会失败因为目标节点不存在，但测试 API 是否正常调用
+    try {
+        await irohTransport.sendMessage(fakeTargetId, 'test', new TextEncoder().encode('test'));
+    }
+    catch (e) {
+        console.log('[Node1] Expected failure:', e.message);
+    }
+    await irohTransport.shutdown();
+    console.log('\n=== Test Complete ===');
+}
+async function testMessageParsing() {
+    console.log('=== Message Parsing Test ===\n');
+    await irohTransport.start();
+    // 测试不同的消息格式
+    const testCases = [
+        { type: 'task', payload: '{"id":"1","type":"summarize"}' },
+        { type: 'relay', payload: 'forward-data' },
+        { type: 'blob', payload: 'binary-data-here' },
+    ];
+    for (const tc of testCases) {
+        const encoded = new TextEncoder().encode(tc.payload);
+        const formatted = tc.type + ':' + tc.payload;
+        console.log(`Parsed: type=${tc.type}, payload_len=${encoded.length}`);
+    }
+    await irohTransport.shutdown();
+    console.log('\n=== Parsing Test Complete ===');
+}
+runTests();
+async function runTests() {
+    try {
+        await testTwoNodesCommunication();
+        await testMessageParsing();
+        console.log('\n✅ All communication tests passed');
+    }
+    catch (e) {
+        console.error('❌ Test failed:', e);
+        process.exit(1);
+    }
+}

package/dist/test/iroh-debug-test.js

@@ -0,0 +1,57 @@
+import { Endpoint } from '@rayhanadev/iroh';
+const IROH_ALPN = 'bolloon/iroh/1';
+async function testConnection() {
+    console.log('=== iroh Connection Debug Test ===\n');
+    console.log('[1] Starting server...');
+    const server = await Endpoint.createWithOptions({ alpns: [IROH_ALPN] });
+    await server.online();
+    console.log(`    Server ID: ${server.nodeId()}`);
+    console.log(`    Server addr: ${server.addr()}`);
+    let acceptResult = null;
+    const acceptPromise = server.accept().then(conn => {
+        acceptResult = conn;
+        console.log('[Server] ✅ Connection accepted!');
+        return conn;
+    }).catch(e => {
+        console.log('[Server] ❌ Accept error:', e.message || e);
+    });
+    console.log('\n[2] Starting client...');
+    const client = await Endpoint.createWithOptions({ alpns: [IROH_ALPN] });
+    await client.online();
+    console.log(`    Client ID: ${client.nodeId()}`);
+    console.log('\n[3] Client connecting to server...');
+    const connectPromise = client.connect(server.nodeId(), IROH_ALPN)
+        .then(conn => {
+        console.log('[Client] ✅ Connected!');
+        return conn;
+    })
+        .catch(e => {
+        console.log('[Client] ❌ Connection error:', e.message || e);
+        return null;
+    });
+    console.log('    Waiting 20s for connection...');
+    const timeout = new Promise(r => setTimeout(r, 20000));
+    const result = await Promise.race([connectPromise, timeout]);
+    if (result && result !== timeout) {
+        console.log('\n[4] Connection established, testing message...');
+        const { send, recv } = await result.openBi();
+        await send.writeAll(Buffer.from('test:hello'));
+        await send.finish();
+        console.log('    Message sent');
+        await new Promise(r => setTimeout(r, 2000));
+        if (acceptResult) {
+            const data = await recv.readToEnd(1024);
+            console.log(`    ✅ Received: "${new TextDecoder().decode(data)}"`);
+            console.log('\n✅ TEST PASSED');
+        }
+    }
+    else if (!result) {
+        console.log('\n❌ Connection failed');
+    }
+    else {
+        console.log('\n⏳ Connection timed out');
+    }
+    await server.close().catch(() => { });
+    await client.close().catch(() => { });
+}
+testConnection().catch(console.error);

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

@@ -0,0 +1,71 @@
+import { AgentAuthManager, KeyManager } from '@diap/sdk';
+import { initIrohIntegration } from '../network/iroh-integration.js';
+const IPFS_API = 'http://127.0.0.1:5001';
+const IPFS_GATEWAY = 'http://127.0.0.1:8080';
+async function main() {
+    console.log('╔═══════════════════════════════════════════╗');
+    console.log('║       iroh + DIAP Integration Test       ║');
+    console.log('╚═══════════════════════════════════════════╝\n');
+    console.log('[1] Generating DIAP identity...');
+    const keyPair = KeyManager.generate();
+    console.log(`    DID: ${keyPair.did}`);
+    console.log(`    Name: test-agent-${keyPair.did.substring(0, 4)}`);
+    console.log('\n[2] Creating AgentAuthManager...');
+    const authManager = await AgentAuthManager.newWithRemoteIpfs(IPFS_API, IPFS_GATEWAY);
+    console.log('    AuthManager ready');
+    console.log('\n[3] Initializing iroh integration...');
+    const integration = await initIrohIntegration({
+        agentAuthManager: authManager,
+        keyPair: keyPair,
+        agentName: `test-agent-${keyPair.did.substring(0, 4)}`,
+        agentDescription: 'Test agent with iroh P2P transport',
+        agentTags: ['test', 'iroh'],
+        refreshIntervalMs: 5 * 60 * 1000,
+        discoveryIntervalMs: 30 * 1000,
+    });
+    const nodeId = integration.getNodeId();
+    console.log(`\n    ✅ Iroh Node ID: ${nodeId}`);
+    const registration = integration.getRegistration();
+    if (registration) {
+        console.log(`    ✅ DIAP CID: ${registration.cid}`);
+    }
+    console.log('\n[4] Setting up message handlers...');
+    integration.onMessage('ping', (msg, from) => {
+        console.log(`\n    📥 Ping from ${from.substring(0, 12)}...`);
+        console.log(`    Payload: "${new TextDecoder().decode(msg.payload)}"`);
+        console.log('    📤 Sending pong...');
+        integration.sendTo(from, 'pong', new TextEncoder().encode('pong from ' + nodeId?.substring(0, 8)));
+    });
+    integration.onMessage('task', (msg, from) => {
+        console.log(`\n    📥 Task from ${from.substring(0, 12)}...`);
+        const taskData = new TextDecoder().decode(msg.payload);
+        console.log(`    Task: ${taskData.substring(0, 80)}...`);
+    });
+    integration.onMessage('response', (msg, from) => {
+        console.log(`\n    📥 Response from ${from.substring(0, 12)}...`);
+        console.log(`    Response: "${new TextDecoder().decode(msg.payload)}"`);
+    });
+    console.log('    Handlers registered for: ping, task, response');
+    console.log('\n[5] Connection info for other peers:');
+    console.log('    ───────────────────────────────────────');
+    console.log(`    Node ID: ${nodeId}`);
+    console.log('    ───────────────────────────────────────');
+    console.log('\n    To connect another peer, use this Node ID.');
+    console.log('\n[6] Waiting for connections (60s)...');
+    let tick = 0;
+    const ticker = setInterval(() => {
+        tick++;
+        const peers = integration.getDiscoveredPeers();
+        const connected = integration.getConnectedPeers();
+        process.stdout.write(`\r    [${tick}s] Discovered: ${peers.length}, Connected: ${connected.length}   `);
+    }, 1000);
+    await new Promise(resolve => setTimeout(resolve, 60000));
+    clearInterval(ticker);
+    console.log('\n\n[7] Shutting down...');
+    await integration.shutdown();
+    console.log('Done');
+}
+main().catch(e => {
+    console.error('Error:', e);
+    process.exit(1);
+});

package/dist/test/iroh-direct-connect.js

@@ -0,0 +1,55 @@
+import { Endpoint } from '@rayhanadev/iroh';
+const IROH_ALPN = 'bolloon/iroh/1';
+async function testConnection() {
+    console.log('=== Direct Connection Test ===\n');
+    // Server
+    console.log('[1] Starting server...');
+    const server = await Endpoint.createWithOptions({ alpns: [IROH_ALPN] });
+    await server.online();
+    const serverId = server.nodeId();
+    console.log(`    Server ID: ${serverId}`);
+    console.log(`    Server addr: ${server.addr()}`);
+    // Accept in background
+    let acceptedConn = null;
+    server.accept().then((conn) => {
+        console.log('[Server] Connection accepted!');
+        acceptedConn = conn;
+    });
+    // Client
+    console.log('\n[2] Starting client...');
+    const client = await Endpoint.createWithOptions({ alpns: [IROH_ALPN] });
+    await client.online();
+    const clientId = client.nodeId();
+    console.log(`    Client ID: ${clientId}`);
+    console.log('\n[3] Client connecting to server...');
+    try {
+        const conn = await client.connect(serverId, IROH_ALPN);
+        console.log('[Client] Connected!');
+        console.log(`    Remote: ${conn.remoteNodeId()}`);
+        // Send message
+        console.log('\n[4] Client sending message...');
+        const { send, recv } = await conn.openBi();
+        await send.writeAll(Buffer.from('hello:world'));
+        await send.finish();
+        console.log('[5] Waiting for server to receive...');
+        await new Promise(r => setTimeout(r, 2000));
+        if (acceptedConn) {
+            console.log('[Server] Reading message...');
+            const data = await recv.readToEnd(1024);
+            console.log(`    Received: "${new TextDecoder().decode(data)}"`);
+            console.log('✅ CONNECTION TEST PASSED');
+        }
+        else {
+            console.log('❌ Server did not accept connection');
+        }
+        conn.close();
+    }
+    catch (e) {
+        console.log('[Client] Connection failed:', e);
+        console.log('❌ CONNECTION TEST FAILED');
+    }
+    await server.close();
+    await client.close();
+    console.log('\nDone');
+}
+testConnection().catch(console.error);

package/dist/test/iroh-e2e-fixed.js

@@ -0,0 +1,89 @@
+import { Endpoint } from '@rayhanadev/iroh';
+const IROH_ALPN = 'bolloon/iroh/1';
+async function testConnection() {
+    console.log('=== iroh E2E Test ===\n');
+    console.log('[1] Starting server...');
+    const server = await Endpoint.createWithOptions({ alpns: [IROH_ALPN] });
+    await server.online();
+    console.log(`    Server ID: ${server.nodeId()}`);
+    let serverConn = null;
+    server.accept().then((conn) => {
+        serverConn = conn;
+        console.log('[Server] ✅ Connection accepted!');
+    }).catch((e) => {
+        console.log('[Server] ❌ Accept error:', e.message || e);
+    });
+    console.log('\n[2] Starting client...');
+    const client = await Endpoint.createWithOptions({ alpns: [IROH_ALPN] });
+    await client.online();
+    console.log(`    Client ID: ${client.nodeId()}`);
+    console.log('\n[3] Client connecting to server...');
+    let clientConn = null;
+    try {
+        clientConn = await client.connect(server.nodeId(), IROH_ALPN);
+        console.log('[Client] ✅ Connected!');
+    }
+    catch (e) {
+        console.log('[Client] ❌ Connection failed:', e.message || e);
+        await server.close();
+        await client.close();
+        return;
+    }
+    console.log('\n[4] Waiting for server to accept connection...');
+    let waitCount = 0;
+    while (!serverConn && waitCount < 20) {
+        await new Promise(r => setTimeout(r, 500));
+        waitCount++;
+        process.stdout.write(`    Waiting... ${waitCount}/20\r`);
+    }
+    console.log('');
+    if (!serverConn) {
+        console.log('❌ Server did not accept connection');
+        await server.close();
+        await client.close();
+        return;
+    }
+    console.log('[5] Client opening bi-stream...');
+    const clientStreams = await clientConn.openBi();
+    console.log('    Bi-stream opened');
+    console.log('[6] Server accepting bi-stream...');
+    let serverStreams = null;
+    try {
+        serverStreams = await serverConn.acceptBi();
+        console.log('    Bi-stream accepted');
+    }
+    catch (e) {
+        console.log('[Server] ❌ Accept bi error:', e.message || e);
+    }
+    if (!serverStreams) {
+        console.log('❌ Server could not accept bi-stream');
+        clientConn.close();
+        await server.close();
+        await client.close();
+        return;
+    }
+    console.log('\n[7] Client sending message...');
+    const { send: clientSend, recv: clientRecv } = clientStreams;
+    const message = 'hello:this is a test message';
+    await clientSend.writeAll(Buffer.from(message));
+    await clientSend.finish();
+    console.log(`    Sent: "${message}"`);
+    console.log('[8] Server receiving message...');
+    const { recv: serverRecv } = serverStreams;
+    const received = await serverRecv.readToEnd(1024);
+    console.log(`    ✅ Received: "${new TextDecoder().decode(received)}"`);
+    console.log('\n[9] Server sending response...');
+    const { send: serverSend } = serverStreams;
+    const response = 'response:hello from server';
+    await serverSend.writeAll(Buffer.from(response));
+    await serverSend.finish();
+    console.log(`    Sent: "${response}"`);
+    console.log('[10] Client receiving response...');
+    const resp = await clientRecv.readToEnd(1024);
+    console.log(`    ✅ Received: "${new TextDecoder().decode(resp)}"`);
+    console.log('\n✅✅✅ FULL E2E TEST PASSED ✅✅✅');
+    clientConn.close();
+    await server.close();
+    await client.close();
+}
+testConnection().catch(console.error);

package/dist/test/iroh-e2e-same-process.js

@@ -0,0 +1,63 @@
+import { irohTransport } from '../network/iroh-transport.js';
+async function testTwoNodes() {
+    console.log('╔═══════════════════════════════════════════╗');
+    console.log('║       iroh Two-Node E2E Test           ║');
+    console.log('╚═══════════════════════════════════════════╝\n');
+    let serverNodeId = null;
+    let clientNodeId = null;
+    let messagesReceived = 0;
+    console.log('[1] Starting server node...');
+    const server = await irohTransport.start();
+    serverNodeId = server.nodeId;
+    console.log(`    Server Node ID: ${serverNodeId}`);
+    console.log('');
+    irohTransport.onMessage('ping', (msg) => {
+        messagesReceived++;
+        console.log(`    [Server] Got ping: "${new TextDecoder().decode(msg.payload)}"`);
+        irohTransport.sendMessage(msg.from, 'pong', new TextEncoder().encode('pong'));
+    });
+    irohTransport.onMessage('request', async (msg) => {
+        messagesReceived++;
+        console.log(`    [Server] Got request: "${new TextDecoder().decode(msg.payload)}"`);
+        const response = await irohTransport.requestResponse(msg.from, 'response', new TextEncoder().encode('response data'));
+        if (response) {
+            console.log(`    [Server] Response sent`);
+        }
+    });
+    console.log('[2] Starting client node...');
+    const clientTransport = new (await import('../network/iroh-transport.js')).IrohTransport();
+    const client = await clientTransport.start();
+    clientNodeId = client.node;
+    console.log(`    Client Node ID: ${clientNodeId}`);
+    console.log('');
+    let clientPongs = 0;
+    let clientResponses = 0;
+    clientTransport.onMessage('pong', (msg) => {
+        clientPongs++;
+        console.log(`    [Client] Got pong: "${new TextDecoder().decode(msg.payload)}"`);
+    });
+    clientTransport.onMessage('response', (msg) => {
+        clientResponses++;
+        console.log(`    [Client] Got response: "${new TextDecoder().decode(msg.payload)}"`);
+    });
+    await new Promise(r => setTimeout(r, 500));
+    console.log('[3] Client sending ping to server...');
+    await clientTransport.sendMessage(serverNodeId, 'ping', new TextEncoder().encode('hello'));
+    await new Promise(r => setTimeout(r, 500));
+    console.log('[4] Client sending request (with response)...');
+    await clientTransport.sendMessage(serverNodeId, 'request', new TextEncoder().encode('need data'));
+    await new Promise(r => setTimeout(r, 2000));
+    console.log('\n[5] Results:');
+    console.log(`    Messages received by server: ${messagesReceived}`);
+    console.log(`    Pongs received by client: ${clientPongs}`);
+    console.log(`    Responses received by client: ${clientResponses}`);
+    const success = messagesReceived >= 2 && clientPongs >= 1 && clientResponses >= 1;
+    console.log('\n' + (success ? '✅ E2E TEST PASSED' : '❌ E2E TEST FAILED'));
+    await clientTransport.shutdown();
+    await irohTransport.shutdown();
+    process.exit(success ? 0 : 1);
+}
+testTwoNodes().catch(e => {
+    console.error('Test failed:', e);
+    process.exit(1);
+});

package/dist/test/iroh-e2e.js

@@ -0,0 +1,66 @@
+import { irohTransport } from '../network/iroh-transport.js';
+const args = process.argv.slice(2);
+const role = args[0];
+const targetNodeId = args[1];
+if (!role || !['server', 'client'].includes(role)) {
+    console.log('Usage:');
+    console.log('  Server: npx tsx src/test/iroh-e2e.ts server');
+    console.log('  Client: npx tsx src/test/iroh-e2e.ts client <server-node-id>');
+    process.exit(1);
+}
+async function runServer() {
+    console.log('[Server] Starting iroh transport...');
+    const node = await irohTransport.start();
+    console.log('[Server] Node ID:', node.nodeId);
+    console.log('[Server] Waiting for connections...\n');
+    let msgCount = 0;
+    irohTransport.onMessage('ping', (msg) => {
+        msgCount++;
+        console.log(`[Server] #${msgCount} Ping from ${msg.from.substring(0, 16)}...`);
+        console.log(`[Server] Payload: "${new TextDecoder().decode(msg.payload)}"`);
+        irohTransport.sendMessage(msg.from, 'pong', new TextEncoder().encode('pong from server'));
+    });
+    irohTransport.onMessage('task', (msg) => {
+        msgCount++;
+        console.log(`[Server] #${msgCount} Task from ${msg.from.substring(0, 16)}...`);
+        const task = new TextDecoder().decode(msg.payload);
+        console.log(`[Server] Task: ${task.substring(0, 60)}...`);
+        irohTransport.sendMessage(msg.from, 'response', new TextEncoder().encode('task received'));
+    });
+    console.log('[Server] Ready. Press Ctrl+C to stop.');
+    await new Promise(() => { });
+}
+async function runClient(targetId) {
+    if (!targetId) {
+        console.error('[Client] Error: target node ID required');
+        process.exit(1);
+    }
+    console.log('[Client] Starting iroh transport...');
+    const node = await irohTransport.start();
+    console.log('[Client] Node ID:', node.nodeId);
+    console.log('[Client] Target:', targetId);
+    console.log('');
+    irohTransport.onMessage('pong', (msg) => {
+        console.log(`[Client] Pong from ${msg.from.substring(0, 16)}...: "${new TextDecoder().decode(msg.payload)}"`);
+    });
+    irohTransport.onMessage('response', (msg) => {
+        console.log(`[Client] Response from ${msg.from.substring(0, 16)}...: "${new TextDecoder().decode(msg.payload)}"`);
+    });
+    await new Promise(resolve => setTimeout(resolve, 500));
+    console.log('[Client] Sending ping...');
+    await irohTransport.sendMessage(targetId, 'ping', new TextEncoder().encode('hello server'));
+    await new Promise(resolve => setTimeout(resolve, 300));
+    console.log('[Client] Sending task...');
+    const task = JSON.stringify({ id: '123', type: 'summarize', documentPath: '/test.pdf' });
+    await irohTransport.sendMessage(targetId, 'task', new TextEncoder().encode(task));
+    console.log('[Client] Waiting for responses...');
+    await new Promise(resolve => setTimeout(resolve, 5000));
+    await irohTransport.shutdown();
+    console.log('[Client] Done');
+}
+if (role === 'server') {
+    runServer();
+}
+else {
+    runClient(targetNodeId);
+}

package/dist/test/iroh-final-e2e.js

@@ -0,0 +1,72 @@
+import { Endpoint } from '@rayhanadev/iroh';
+const IROH_ALPN = 'bolloon/iroh/1';
+async function main() {
+    console.log('=== iroh E2E Final Test ===\n');
+    const serverEndpoint = await Endpoint.createWithOptions({ alpns: [IROH_ALPN] });
+    await serverEndpoint.online();
+    console.log('[Server] Started, ID:', serverEndpoint.nodeId().substring(0, 16) + '...');
+    const clientEndpoint = await Endpoint.createWithOptions({ alpns: [IROH_ALPN] });
+    await clientEndpoint.online();
+    console.log('[Client] Started, ID:', clientEndpoint.nodeId().substring(0, 16) + '...');
+    let serverConn = null;
+    let serverConnPromise = serverEndpoint.accept().then(c => { serverConn = c; return c; });
+    console.log('[Client] Connecting to server...');
+    let clientConn = null;
+    try {
+        clientConn = await clientEndpoint.connect(serverEndpoint.nodeId(), IROH_ALPN);
+        console.log('[Client] ✅ Connected!');
+    }
+    catch (e) {
+        console.log('[Client] ❌ Failed:', e.message);
+        return;
+    }
+    console.log('[Server] Waiting for accept...');
+    try {
+        await serverConnPromise;
+        console.log('[Server] ✅ Connection accepted!');
+    }
+    catch (e) {
+        console.log('[Server] ❌ Accept failed:', e.message);
+        return;
+    }
+    console.log('[Client] Opening bi-stream...');
+    let clientBi = null;
+    try {
+        clientBi = await clientConn.openBi();
+        console.log('[Client] ✅ Bi-stream opened');
+    }
+    catch (e) {
+        console.log('[Client] ❌ openBi failed:', e.message);
+        return;
+    }
+    console.log('[Server] Accepting bi-stream...');
+    let serverBi = null;
+    try {
+        serverBi = await serverConn.acceptBi();
+        console.log('[Server] ✅ Bi-stream accepted');
+    }
+    catch (e) {
+        console.log('[Server] ❌ acceptBi failed:', e.message);
+        return;
+    }
+    console.log('\n[Test] Sending message client → server...');
+    const { send: cSend, recv: cRecv } = clientBi;
+    await cSend.writeAll(Buffer.from('hello from client'));
+    await cSend.finish();
+    const { recv: sRecv, send: sSend } = serverBi;
+    const msg = await sRecv.readToEnd(1024);
+    console.log('[Server] ✅ Received:', new TextDecoder().decode(msg));
+    console.log('[Server] Sending response...');
+    await sSend.writeAll(Buffer.from('hello from server'));
+    await sSend.finish();
+    const resp = await cRecv.readToEnd(1024);
+    console.log('[Client] ✅ Received:', new TextDecoder().decode(resp));
+    console.log('\n✅✅✅ E2E TEST PASSED ✅✅✅');
+    clientConn.close();
+    await serverEndpoint.close();
+    await clientEndpoint.close();
+}
+main().catch(e => {
+    console.error('Error:', e);
+    process.exit(1);
+});

package/dist/test/iroh-relay-test.js

@@ -0,0 +1,37 @@
+import { Endpoint } from '@rayhanadev/iroh';
+const IROH_ALPN = 'bolloon/iroh/1';
+async function testConnection() {
+    console.log('=== iroh Relay Connection Test ===\n');
+    console.log('[1] Starting server...');
+    const server = await Endpoint.createWithOptions({ alpns: [IROH_ALPN] });
+    await server.online();
+    console.log(`    Server ID: ${server.nodeId()}`);
+    console.log(`    Server addr: ${server.addr()}`);
+    console.log('\n[2] Starting client...');
+    const client = await Endpoint.createWithOptions({ alpns: [IROH_ALPN] });
+    await client.online();
+    console.log(`    Client ID: ${client.nodeId()}`);
+    console.log('\n[3] Client connecting to server via relay...');
+    try {
+        console.log('    Waiting for connection (relay may take time)...');
+        const conn = await client.connect(server.nodeId(), IROH_ALPN);
+        console.log('[Client] ✅ Connected!');
+        console.log(`    Remote: ${conn.remoteNodeId()}`);
+        console.log('\n[4] Client sending message...');
+        const { send, recv } = await conn.openBi();
+        await send.writeAll(Buffer.from('hello:test message'));
+        await send.finish();
+        console.log('    Message sent');
+        console.log('\n[5] Server receiving...');
+        const data = await recv.readToEnd(1024);
+        console.log(`    ✅ Received: "${new TextDecoder().decode(data)}"`);
+        console.log('\n✅ FULL E2E TEST PASSED');
+        conn.close();
+    }
+    catch (e) {
+        console.log('[Client] ❌ Connection failed:', e.message || e);
+    }
+    await server.close();
+    await client.close();
+}
+testConnection().catch(console.error);

package/dist/test/iroh-simple-test.js

@@ -0,0 +1,41 @@
+import { Endpoint } from '@rayhanadev/iroh';
+const IROH_ALPN = 'bolloon/iroh/1';
+async function testConnection() {
+    console.log('=== iroh E2E Test (Simple) ===\n');
+    console.log('[1] Starting server...');
+    const server = await Endpoint.createWithOptions({ alpns: [IROH_ALPN] });
+    await server.online();
+    console.log(`    Server ID: ${server.nodeId()}`);
+    console.log('[2] Starting client...');
+    const client = await Endpoint.createWithOptions({ alpns: [IROH_ALPN] });
+    await client.online();
+    console.log(`    Client ID: ${client.nodeId()}`);
+    console.log('\n[3] Client connecting...');
+    let clientConn = null;
+    try {
+        clientConn = await client.connect(server.nodeId(), IROH_ALPN);
+        console.log('[Client] ✅ Connected!');
+    }
+    catch (e) {
+        console.log('[Client] ❌ Failed:', e.message || e);
+        await server.close();
+        await client.close();
+        return;
+    }
+    console.log('[4] Client sending datagram...');
+    try {
+        clientConn.sendDatagram(Buffer.from('hello:test datagram'));
+        console.log('    Datagram sent');
+    }
+    catch (e) {
+        console.log('[Client] ❌ Datagram failed:', e.message || e);
+    }
+    console.log('[5] Waiting 3s...');
+    await new Promise(r => setTimeout(r, 3000));
+    console.log('[6] Closing connections...');
+    clientConn.close();
+    await server.close();
+    await client.close();
+    console.log('\n✅ Connection test completed');
+}
+testConnection().catch(console.error);