@bolloon/bolloon-agent 0.1.0

package/src/test/iroh-debug-test.ts

@@ -0,0 +1,69 @@
+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: any = 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/src/test/iroh-diap-test.ts

@@ -0,0 +1,90 @@
+import { AgentAuthManager, KeyManager } from '@diap/sdk';
+import { initIrohIntegration, getIrohIntegration } 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/src/test/iroh-direct-connect.ts

@@ -0,0 +1,65 @@
+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: any = null;
+  server.accept().then((conn: any) => {
+    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/src/test/iroh-e2e-fixed.ts

@@ -0,0 +1,106 @@
+import { Endpoint, Connection } 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: Connection | null = null;
+
+  server.accept().then((conn: Connection) => {
+    serverConn = conn;
+    console.log('[Server] ✅ Connection accepted!');
+  }).catch((e: any) => {
+    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: any = null;
+  try {
+    clientConn = await client.connect(server.nodeId(), IROH_ALPN);
+    console.log('[Client] ✅ Connected!');
+  } catch (e: any) {
+    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: any = null;
+  try {
+    serverStreams = await serverConn.acceptBi();
+    console.log('    Bi-stream accepted');
+  } catch (e: any) {
+    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/src/test/iroh-e2e-same-process.ts

@@ -0,0 +1,83 @@
+import { irohTransport } from '../network/iroh-transport.js';
+
+async function testTwoNodes() {
+  console.log('╔═══════════════════════════════════════════╗');
+  console.log('║       iroh Two-Node E2E Test           ║');
+  console.log('╚═══════════════════════════════════════════╝\n');
+
+  let serverNodeId: string | null = null;
+  let clientNodeId: string | null = 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/src/test/iroh-e2e.ts

@@ -0,0 +1,83 @@
+import { irohTransport } from '../network/iroh-transport.js';
+
+const args = process.argv.slice(2);
+const role = args[0] as 'server' | 'client';
+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: string) {
+  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/src/test/iroh-final-e2e.ts

@@ -0,0 +1,84 @@
+import { Endpoint, Connection } 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: Connection | null = null;
+  let serverConnPromise = serverEndpoint.accept().then(c => { serverConn = c; return c; });
+
+  console.log('[Client] Connecting to server...');
+  let clientConn: any = null;
+  try {
+    clientConn = await clientEndpoint.connect(serverEndpoint.nodeId(), IROH_ALPN);
+    console.log('[Client] ✅ Connected!');
+  } catch (e: any) {
+    console.log('[Client] ❌ Failed:', e.message);
+    return;
+  }
+
+  console.log('[Server] Waiting for accept...');
+  try {
+    await serverConnPromise;
+    console.log('[Server] ✅ Connection accepted!');
+  } catch (e: any) {
+    console.log('[Server] ❌ Accept failed:', e.message);
+    return;
+  }
+
+  console.log('[Client] Opening bi-stream...');
+  let clientBi: any = null;
+  try {
+    clientBi = await clientConn.openBi();
+    console.log('[Client] ✅ Bi-stream opened');
+  } catch (e: any) {
+    console.log('[Client] ❌ openBi failed:', e.message);
+    return;
+  }
+
+  console.log('[Server] Accepting bi-stream...');
+  let serverBi: any = null;
+  try {
+    serverBi = await serverConn!.acceptBi();
+    console.log('[Server] ✅ Bi-stream accepted');
+  } catch (e: any) {
+    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/src/test/iroh-relay-test.ts

@@ -0,0 +1,46 @@
+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: any) {
+    console.log('[Client] ❌ Connection failed:', e.message || e);
+  }
+
+  await server.close();
+  await client.close();
+}
+
+testConnection().catch(console.error);

package/src/test/iroh-simple-test.ts

@@ -0,0 +1,49 @@
+import { Endpoint, Connection } 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: any = null;
+  try {
+    clientConn = await client.connect(server.nodeId(), IROH_ALPN);
+    console.log('[Client] ✅ Connected!');
+  } catch (e: any) {
+    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: any) {
+    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);