@highway1/cli 0.1.41 → 0.1.42

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@highway1/cli",
-  "version": "0.1.41",
+  "version": "0.1.42",
   "description": "CLI tool for Clawiverse network",
   "type": "module",
   "bin": {
@@ -13,7 +13,7 @@
     "clean": "rm -rf dist"
   },
   "dependencies": {
-    "@highway1/core": "^0.1.30",
+    "@highway1/core": "^0.1.41",
     "chalk": "^5.3.0",
     "cli-table3": "^0.6.5",
     "commander": "^12.1.0",

package/src/commands/join.ts

@@ -60,16 +60,31 @@ export function registerJoinCommand(program: Command): void {
         const connectSpin = spinner('Connecting to bootstrap peers...');
 
         // Phase 1: wait for peer:connect (up to 10s)
+        let connected = false;
         await new Promise<void>((resolve) => {
           const timeout = setTimeout(resolve, 10000);
           node.libp2p.addEventListener('peer:connect', () => {
+            connected = true;
             clearTimeout(timeout);
             resolve();
           }, { once: true });
         });
 
-        // Phase 2: wait for relay reservation (up to 15s after connection)
-        // Check if we already have relay addresses (might be auto-added by libp2p)
+        // If discovery has not connected us yet, proactively dial bootstrap peers once.
+        if (!connected && bootstrapPeers.length > 0) {
+          info('No peer discovered yet, dialing bootstrap peers...');
+          for (const bootstrapAddr of bootstrapPeers) {
+            try {
+              await node.libp2p.dial(bootstrapAddr);
+              connected = true;
+              break;
+            } catch {
+              // try next bootstrap peer
+            }
+          }
+        }
+
+        // Phase 2: wait for relay reservation using event + polling (more reliable across libp2p versions)
         const countRelayAddrs = () => node.getMultiaddrs().filter(a => a.includes('/p2p-circuit')).length;
         const initialRelayCount = countRelayAddrs();
 
@@ -77,32 +92,63 @@ export function registerJoinCommand(program: Command): void {
         info('Waiting for relay reservation...');
 
         let reservationSucceeded = false;
-        await new Promise<void>((resolve) => {
-          const timeout = setTimeout(() => {
-            if (!reservationSucceeded) {
-              info(`Relay reservation timeout after 15s.`);
-              info(`Connected peers: ${node.libp2p.getPeers().map(p => p.toString()).join(', ')}`);
-            }
-            resolve();
-          }, 15000);
+        if (initialRelayCount === 0) {
+          await new Promise<void>((resolve) => {
+            const RELAY_WAIT_MS = 30000;
+            const POLL_MS = 500;
+            let settled = false;
+
+            const finish = () => {
+              if (settled) return;
+              settled = true;
+              clearTimeout(timeout);
+              clearInterval(pollTimer);
+              (node.libp2p as any).removeEventListener('relay:reservation', onReservation);
+              (node.libp2p as any).removeEventListener('self:peer:update', onPeerUpdate);
+              resolve();
+            };
+
+            const onReservation = () => {
+              reservationSucceeded = true;
+              info('✓ Relay reservation successful!');
+              setTimeout(finish, 300);
+            };
+
+            const onPeerUpdate = () => {
+              if (countRelayAddrs() > 0) {
+                reservationSucceeded = true;
+                info('✓ Relay address detected from peer update');
+                finish();
+              }
+            };
 
-          // Listen for relay:reservation event (fires when reservation succeeds)
-          const onReservation = () => {
-            reservationSucceeded = true;
-            info(`✓ Relay reservation successful!`);
-            clearTimeout(timeout);
-            setTimeout(resolve, 500);
-          };
+            const pollTimer = setInterval(() => {
+              if (countRelayAddrs() > 0) {
+                reservationSucceeded = true;
+                info('✓ Relay address detected');
+                finish();
+              }
+            }, POLL_MS);
 
-          (node.libp2p as any).addEventListener('relay:reservation', onReservation, { once: true });
+            const timeout = setTimeout(() => {
+              if (!reservationSucceeded) {
+                info(`Relay reservation timeout after ${RELAY_WAIT_MS / 1000}s.`);
+                info(`Connected peers: ${node.libp2p.getPeers().map(p => p.toString()).join(', ')}`);
+              }
+              finish();
+            }, RELAY_WAIT_MS);
 
-          setTimeout(() => {
-            (node.libp2p as any).removeEventListener('relay:reservation', onReservation);
-          }, 15000);
-        });
+            // Event names vary by libp2p internals; keep as any to avoid typing mismatch.
+            (node.libp2p as any).addEventListener('relay:reservation', onReservation);
+            (node.libp2p as any).addEventListener('self:peer:update', onPeerUpdate);
+          });
+        } else {
+          reservationSucceeded = true;
+          info('✓ Relay address already present');
+        }
 
         if (!reservationSucceeded) {
-          info('⚠ Relay reservation did not complete - using fallback relay addresses');
+          info('⚠ Relay reservation did not complete, continuing with fallback relay addresses');
         }
 
         connectSpin.succeed('Connected to network!');