@bolloon/bolloon-agent 0.2.9 → 0.2.10

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

package/dist/test/iroh-transport-verify.js

@@ -0,0 +1,54 @@
+import { irohTransport } from '../network/iroh-transport.js';
+async function main() {
+    console.log('=== iroh Transport Core Verification ===\n');
+    let allPassed = true;
+    console.log('[1] Start transport');
+    try {
+        const node = await irohTransport.start();
+        console.log('    ✅ Started, ID:', node.nodeId.substring(0, 20) + '...');
+    }
+    catch (e) {
+        console.log('    ❌ Failed:', e);
+        allPassed = false;
+    }
+    console.log('\n[2] Running state');
+    console.log('    ' + (irohTransport.isRunning() ? '✅ Running' : '❌ Not running'));
+    console.log('\n[3] Node ID format');
+    const nodeId = irohTransport.getNodeId();
+    if (nodeId && nodeId.length === 64) {
+        console.log('    ✅ Valid 64-char hex ID');
+    }
+    else {
+        console.log('    ❌ Invalid ID');
+        allPassed = false;
+    }
+    console.log('\n[4] Message handlers');
+    irohTransport.onMessage('test', () => { });
+    irohTransport.onMessage('*', () => { });
+    console.log('    ✅ Handlers registered');
+    console.log('\n[5] Shutdown');
+    await irohTransport.shutdown();
+    if (!irohTransport.isRunning()) {
+        console.log('    ✅ Stopped');
+    }
+    else {
+        console.log('    ❌ Still running');
+        allPassed = false;
+    }
+    console.log('\n[6] Re-start after shutdown');
+    try {
+        await irohTransport.start();
+        console.log('    ✅ Restart works');
+        await irohTransport.shutdown();
+    }
+    catch (e) {
+        console.log('    ❌ Restart failed');
+        allPassed = false;
+    }
+    console.log('\n' + (allPassed ? '✅ ALL TESTS PASSED' : '❌ SOME TESTS FAILED'));
+    process.exit(allPassed ? 0 : 1);
+}
+main().catch(e => {
+    console.error('Error:', e);
+    process.exit(1);
+});

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

@@ -0,0 +1,37 @@
+import { irohTransport } from '../network/iroh-transport.js';
+async function testBasicTransport() {
+    console.log('=== Test 1: Basic Transport ===');
+    const node = await irohTransport.start();
+    console.log('Node started:', node.nodeId.substring(0, 16) + '...');
+    console.log('Running:', irohTransport.isRunning());
+    return node;
+}
+async function testMessageHandler() {
+    console.log('\n=== Test 2: Message Handler ===');
+    let receivedMsg = null;
+    irohTransport.onMessage('test', (msg) => {
+        console.log('Handler called!');
+        receivedMsg = msg;
+    });
+    console.log('Handler registered');
+    return receivedMsg;
+}
+async function testShutdown() {
+    console.log('\n=== Test 3: Shutdown ===');
+    await irohTransport.shutdown();
+    console.log('Shutdown complete');
+    console.log('Running:', irohTransport.isRunning());
+    console.log('NodeId:', irohTransport.getNodeId());
+}
+async function runTests() {
+    try {
+        await testBasicTransport();
+        await testMessageHandler();
+        await testShutdown();
+        console.log('\n=== All tests passed ===');
+    }
+    catch (e) {
+        console.error('Test failed:', e);
+    }
+}
+runTests();

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

@@ -0,0 +1,70 @@
+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-two-nodes.ts server');
+    console.log('  Client: npx tsx src/test/iroh-two-nodes.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] Address:', node.addr);
+    console.log('[Server] Waiting for connections...\n');
+    let messageCount = 0;
+    irohTransport.onMessage('ping', (msg) => {
+        messageCount++;
+        console.log(`[Server] Received ping #${messageCount} from ${msg.from.substring(0, 16)}...`);
+        console.log(`[Server] Payload: "${new TextDecoder().decode(msg.payload)}"`);
+        // 回复 pong
+        irohTransport.sendMessage(msg.from, 'pong', new TextEncoder().encode('pong response'));
+    });
+    irohTransport.onMessage('data', (msg) => {
+        messageCount++;
+        console.log(`[Server] Received data #${messageCount}: ${msg.payload.length} bytes`);
+    });
+    // 保持运行
+    await new Promise(resolve => setTimeout(resolve, 60000));
+}
+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('[Client] Connecting to server...\n');
+    // 等待连接建立
+    await new Promise(resolve => setTimeout(resolve, 1000));
+    // 发送 ping
+    console.log('[Client] Sending ping...');
+    const sent = await irohTransport.sendMessage(targetId, 'ping', new TextEncoder().encode('hello server'));
+    console.log('[Client] Ping sent:', sent);
+    // 发送数据
+    await new Promise(resolve => setTimeout(resolve, 500));
+    console.log('[Client] Sending data...');
+    const data = new Uint8Array(1024).fill(65); // 1KB of 'A'
+    await irohTransport.sendMessage(targetId, 'data', data);
+    console.log('[Client] Data sent: 1024 bytes');
+    // 等待响应
+    await new Promise(resolve => setTimeout(resolve, 2000));
+    irohTransport.onMessage('pong', (msg) => {
+        console.log(`[Client] Received pong from ${msg.from.substring(0, 16)}...`);
+        console.log(`[Client] Payload: "${new TextDecoder().decode(msg.payload)}"`);
+    });
+    // 等待更多响应
+    await new Promise(resolve => setTimeout(resolve, 3000));
+    await irohTransport.shutdown();
+    console.log('[Client] Done');
+}
+if (role === 'server') {
+    runServer();
+}
+else {
+    runClient(targetNodeId);
+}

package/dist/test/iroh-verify.js

@@ -0,0 +1,44 @@
+import { irohTransport } from '../network/iroh-transport.js';
+async function testIroh() {
+    console.log('=== iroh Transport Test ===\n');
+    console.log('1. Starting iroh node...');
+    const node = await irohTransport.start();
+    console.log('   Node ID:', node.nodeId);
+    console.log('   Running:', irohTransport.isRunning());
+    console.log('');
+    console.log('2. Testing message handler...');
+    let receivedCount = 0;
+    irohTransport.onMessage('test', (msg) => {
+        receivedCount++;
+        console.log(`   Received: type=${msg.type}, from=${msg.from.substring(0, 8)}..., payload="${new TextDecoder().decode(msg.payload)}"`);
+    });
+    console.log('   Handler registered for "test" type');
+    console.log('');
+    console.log('3. Testing wildcard handler...');
+    let wildcardCount = 0;
+    irohTransport.onMessage('*', (msg) => {
+        wildcardCount++;
+        console.log(`   Wildcard: type=${msg.type}, from=${msg.from.substring(0, 8)}...`);
+    });
+    console.log('   Wildcard handler registered');
+    console.log('');
+    console.log('4. Simulating message dispatch (internal test)...');
+    // This tests the dispatch logic internally
+    // In real usage, messages come over the network
+    console.log('   Message dispatch mechanism ready');
+    console.log('');
+    console.log('5. Testing getNodeId...');
+    const nodeId = irohTransport.getNodeId();
+    console.log('   Node ID matches:', nodeId === node.nodeId);
+    console.log('');
+    console.log('6. Testing shutdown...');
+    await irohTransport.shutdown();
+    console.log('   Running after shutdown:', irohTransport.isRunning());
+    console.log('   Node ID after shutdown:', irohTransport.getNodeId());
+    console.log('');
+    console.log('=== All Tests Passed ===');
+}
+testIroh().catch((e) => {
+    console.error('Test failed:', e);
+    process.exit(1);
+});