@highway1/cli 0.1.41 → 0.1.43

package/dist/index.js

@@ -116515,7 +116515,8 @@ function createDHTOperations(libp2p) {
         searchEngine.indexAgentCard(card);
         logger4.info("Published Agent Card to DHT", { did: card.did });
       } catch (error2) {
-        throw new DiscoveryError("Failed to publish Agent Card", error2);
+        logger4.warn("Failed to publish Agent Card to DHT (non-fatal)", { error: error2.message });
+        searchEngine.indexAgentCard(card);
       }
     },
     queryAgentCard: async (did) => {
@@ -118327,6 +118328,7 @@ function registerJoinCommand(program2) {
         privateKey: identity3.privateKey
       });
       const bootstrapPeers = options.bootstrap || getBootstrapPeers();
+      const bootstrapPeerIds = bootstrapPeers.map((addr) => addr.split("/p2p/")[1]).filter((peerId) => Boolean(peerId));
       const node = await createNode({
         keyPair,
         bootstrapPeers,
@@ -118340,39 +118342,80 @@ function registerJoinCommand(program2) {
       info(`DID: ${identity3.did}`);
       info(`Listening on: ${node.getMultiaddrs().join(", ")}`);
       const connectSpin = spinner("Connecting to bootstrap peers...");
+      let connected = false;
       await new Promise((resolve) => {
         const timeout = setTimeout(resolve, 1e4);
         node.libp2p.addEventListener("peer:connect", () => {
+          connected = true;
           clearTimeout(timeout);
           resolve();
         }, { once: true });
       });
+      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 {
+          }
+        }
+      }
       const countRelayAddrs = () => node.getMultiaddrs().filter((a2) => a2.includes("/p2p-circuit")).length;
       const initialRelayCount = countRelayAddrs();
       info(`Initial relay addresses: ${initialRelayCount}`);
       info("Waiting for relay reservation...");
       let reservationSucceeded = false;
-      await new Promise((resolve) => {
-        const timeout = setTimeout(() => {
-          if (!reservationSucceeded) {
-            info(`Relay reservation timeout after 15s.`);
-            info(`Connected peers: ${node.libp2p.getPeers().map((p2) => p2.toString()).join(", ")}`);
-          }
-          resolve();
-        }, 15e3);
-        const onReservation = () => {
-          reservationSucceeded = true;
-          info(`\u2713 Relay reservation successful!`);
-          clearTimeout(timeout);
-          setTimeout(resolve, 500);
-        };
-        node.libp2p.addEventListener("relay:reservation", onReservation, { once: true });
-        setTimeout(() => {
-          node.libp2p.removeEventListener("relay:reservation", onReservation);
-        }, 15e3);
-      });
+      if (initialRelayCount === 0) {
+        await new Promise((resolve) => {
+          const RELAY_WAIT_MS = 3e4;
+          const POLL_MS = 500;
+          let settled = false;
+          const finish = () => {
+            if (settled) return;
+            settled = true;
+            clearTimeout(timeout);
+            clearInterval(pollTimer);
+            node.libp2p.removeEventListener("relay:reservation", onReservation);
+            node.libp2p.removeEventListener("self:peer:update", onPeerUpdate);
+            resolve();
+          };
+          const onReservation = () => {
+            reservationSucceeded = true;
+            info("\u2713 Relay reservation successful!");
+            setTimeout(finish, 300);
+          };
+          const onPeerUpdate = () => {
+            if (countRelayAddrs() > 0) {
+              reservationSucceeded = true;
+              info("\u2713 Relay address detected from peer update");
+              finish();
+            }
+          };
+          const pollTimer = setInterval(() => {
+            if (countRelayAddrs() > 0) {
+              reservationSucceeded = true;
+              info("\u2713 Relay address detected");
+              finish();
+            }
+          }, POLL_MS);
+          const timeout = setTimeout(() => {
+            if (!reservationSucceeded) {
+              info(`Relay reservation timeout after ${RELAY_WAIT_MS / 1e3}s.`);
+              info(`Connected peers: ${node.libp2p.getPeers().map((p2) => p2.toString()).join(", ")}`);
+            }
+            finish();
+          }, RELAY_WAIT_MS);
+          node.libp2p.addEventListener("relay:reservation", onReservation);
+          node.libp2p.addEventListener("self:peer:update", onPeerUpdate);
+        });
+      } else {
+        reservationSucceeded = true;
+        info("\u2713 Relay address already present");
+      }
       if (!reservationSucceeded) {
-        info("\u26A0 Relay reservation did not complete - using fallback relay addresses");
+        info("\u26A0 Relay reservation did not complete, continuing with fallback relay addresses");
       }
       connectSpin.succeed("Connected to network!");
       const cardSpin = spinner("Publishing Agent Card to DHT...");
@@ -118407,6 +118450,19 @@ function registerJoinCommand(program2) {
       const dht = createDHTOperations(node.libp2p);
       await dht.publishAgentCard(signedCard);
       cardSpin.succeed("Agent Card published!");
+      const ensureBootstrapConnections = async () => {
+        const connections = node.libp2p.getConnections();
+        const connectedPeerIds = new Set(connections.map((conn) => conn.remotePeer.toString()));
+        for (const bootstrapAddr of bootstrapPeers) {
+          const targetPeerId = bootstrapAddr.split("/p2p/")[1];
+          if (!targetPeerId || connectedPeerIds.has(targetPeerId)) continue;
+          try {
+            await node.libp2p.dial(bootstrapAddr);
+            info(`Reconnected bootstrap peer: ${targetPeerId}`);
+          } catch {
+          }
+        }
+      };
       const pingInterval = setInterval(async () => {
         const peers = node.libp2p.getPeers();
         if (peers.length === 0) {
@@ -118419,6 +118475,7 @@ function registerJoinCommand(program2) {
             }
           }
         } else {
+          await ensureBootstrapConnections();
           for (const peer of peers) {
             try {
               await node.libp2p.services.ping.ping(peer);
@@ -118427,6 +118484,21 @@ function registerJoinCommand(program2) {
           }
         }
       }, 15e3);
+      const onPeerDisconnect = async (evt) => {
+        const disconnectedPeerId = evt?.detail?.toString?.() ?? "";
+        if (!bootstrapPeerIds.includes(disconnectedPeerId)) return;
+        info(`Bootstrap peer disconnected: ${disconnectedPeerId}, attempting reconnect...`);
+        for (const bootstrapAddr of bootstrapPeers) {
+          if (!bootstrapAddr.endsWith(`/p2p/${disconnectedPeerId}`)) continue;
+          try {
+            await node.libp2p.dial(bootstrapAddr);
+            info(`Recovered bootstrap connection: ${disconnectedPeerId}`);
+            return;
+          } catch {
+          }
+        }
+      };
+      node.libp2p.addEventListener("peer:disconnect", onPeerDisconnect);
       const verifyFn = async (signature, data) => {
         try {
           const decoded = JSON.parse(new TextDecoder().decode(data));
@@ -118495,6 +118567,7 @@ function registerJoinCommand(program2) {
         console.log();
         const stopSpin = spinner("Stopping node...");
         clearInterval(pingInterval);
+        node.libp2p.removeEventListener("peer:disconnect", onPeerDisconnect);
         await router.stop();
         await node.stop();
         stopSpin.succeed("Node stopped");