@highway1/cli 0.1.37 → 0.1.39

package/dist/index.js

@@ -116490,11 +116490,15 @@ function createDHTOperations(libp2p) {
             break;
           }
         }
-        const caps = (card.capabilities ?? []).map(
-          (c2) => typeof c2 === "string" ? c2 : c2.name
-        ).filter(Boolean);
+        const caps = (card.capabilities ?? []).flatMap((c2) => {
+          if (typeof c2 === "string") return [c2];
+          return [c2.name, c2.id].filter(Boolean);
+        });
         caps.push("__all__");
         const importantCaps = ["__all__"];
+        if (caps.some((cap) => capKey(cap) === "relay")) {
+          importantCaps.push("relay");
+        }
         await Promise.all(importantCaps.map(async (cap) => {
           const capKeyStr = `/clawiverse/cap/${capKey(cap)}`;
           const capDHTKey = fromString2(capKeyStr);
@@ -116774,13 +116778,13 @@ function createMessageRouter(libp2p, verifyFn, dht, relayPeers) {
           } catch {
           }
         }
+        let lastError;
         if (!stream) {
           const allRelayAddrs = [
             ...relayMultiaddrs,
             ...(relayPeers ?? []).map((r2) => buildCircuitRelayAddr(r2, targetPeerIdStr))
           ];
           const uniqueRelayAddrs = [...new Set(allRelayAddrs)];
-          let lastError;
           for (const addr of uniqueRelayAddrs) {
             try {
               const conn = await libp2p.dial(multiaddr(addr));
@@ -116793,7 +116797,6 @@ function createMessageRouter(libp2p, verifyFn, dht, relayPeers) {
               lastError = relayErr;
             }
           }
-          if (!stream) throw lastError ?? new MessagingError("All dial attempts failed");
         }
         if (!stream && dht && "queryRelayPeers" in dht) {
           const discoveredRelays = await dht.queryRelayPeers();
@@ -116806,9 +116809,12 @@ function createMessageRouter(libp2p, verifyFn, dht, relayPeers) {
               break;
             } catch (e2) {
               logger5.warn("DHT relay failed", { relayAddr, error: e2.message });
+              lastError = e2;
             }
           }
-          if (!stream) throw new MessagingError("All dial attempts failed (including DHT-discovered relays)");
+        }
+        if (!stream) {
+          throw lastError ?? new MessagingError("All dial attempts failed (including DHT-discovered relays)");
         }
         const encoded = encodeMessage2(envelope);
         await stream.sink(
@@ -116891,7 +116897,7 @@ function createMessageRouter(libp2p, verifyFn, dht, relayPeers) {
 function buildCircuitRelayAddr(relayAddr, targetPeerId) {
   return `${relayAddr}/p2p-circuit/p2p/${targetPeerId}`;
 }
-async function handleIncomingStream(stream, handlers, catchAllHandler, _verifyFn) {
+async function handleIncomingStream(stream, handlers, catchAllHandler, verifyFn) {
   try {
     const chunks = [];
     for await (const chunk of stream.source) {
@@ -116910,6 +116916,37 @@ async function handleIncomingStream(stream, handlers, catchAllHandler, _verifyFn
       logger5.warn("Received invalid message envelope");
       return;
     }
+    const isValidSignature = await verifyEnvelope(envelope, async (signature, data2) => {
+      const senderPublicKey = extractPublicKey(envelope.from);
+      return verify(signature, data2, senderPublicKey);
+    });
+    if (!isValidSignature) {
+      logger5.warn("Received message with invalid signature", {
+        id: envelope.id,
+        from: envelope.from
+      });
+      return;
+    }
+    try {
+      const { signature, ...envelopeWithoutSig } = envelope;
+      const dataBytes = new TextEncoder().encode(JSON.stringify(envelopeWithoutSig));
+      const signatureBytes = Buffer.from(signature, "hex");
+      const hookValid = await verifyFn(signatureBytes, dataBytes);
+      if (!hookValid) {
+        logger5.warn("Message rejected by custom verifier", {
+          id: envelope.id,
+          from: envelope.from
+        });
+        return;
+      }
+    } catch (error2) {
+      logger5.warn("Custom verification hook failed", {
+        id: envelope.id,
+        from: envelope.from,
+        error: error2.message
+      });
+      return;
+    }
     logger5.info("Received message", {
       id: envelope.id,
       from: envelope.from,
@@ -118310,41 +118347,32 @@ function registerJoinCommand(program2) {
           resolve();
         }, { once: true });
       });
-      const hasRelayAddr = () => node.getMultiaddrs().some((a2) => a2.includes("/p2p-circuit"));
-      if (!hasRelayAddr()) {
-        info("Waiting for relay reservation...");
-        info(`Listen addresses configured: ${JSON.stringify(node.libp2p.components?.addressManager?.getListenAddrs?.() || [])}`);
-        await new Promise((resolve) => {
-          const timeout = setTimeout(() => {
-            info(`Relay reservation timeout after 10s.`);
-            info(`Final multiaddrs: ${node.getMultiaddrs().join(", ")}`);
+      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();
-          }, 1e4);
-          const onReservation = (evt) => {
-            info(`Relay reservation successful! Details: ${JSON.stringify(evt.detail)}`);
-            clearTimeout(timeout);
-            setTimeout(() => {
-              info(`Relay addresses: ${node.getMultiaddrs().filter((a2) => a2.includes("/p2p-circuit")).join(", ")}`);
-              resolve();
-            }, 500);
-          };
-          const onPeerUpdate = () => {
-            if (hasRelayAddr()) {
-              info(`Relay address acquired via peer update`);
-              clearTimeout(timeout);
-              resolve();
-            }
-          };
-          node.libp2p.addEventListener("relay:reservation", onReservation, { once: true });
-          node.libp2p.addEventListener("self:peer:update", onPeerUpdate);
-          setTimeout(() => {
-            node.libp2p.removeEventListener("relay:reservation", onReservation);
-            node.libp2p.removeEventListener("self:peer:update", onPeerUpdate);
-          }, 1e4);
-        });
-      } else {
-        info(`Relay address already present: ${node.getMultiaddrs().filter((a2) => a2.includes("/p2p-circuit")).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 (!reservationSucceeded) {
+        info("\u26A0 Relay reservation did not complete - using fallback relay addresses");
       }
       connectSpin.succeed("Connected to network!");
       const cardSpin = spinner("Publishing Agent Card to DHT...");
@@ -118352,8 +118380,18 @@ function registerJoinCommand(program2) {
       const relayAddrs = node.getMultiaddrs().filter((a2) => a2.includes("/p2p-circuit"));
       const fallbackRelayAddrs = relayAddrs.length === 0 ? bootstrapPeers.map((r2) => `${r2}/p2p-circuit/p2p/${node.getPeerId()}`) : [];
       const allAddrs = [...directAddrs, ...relayAddrs, ...fallbackRelayAddrs];
-      const capabilities = [...card.capabilities ?? []];
-      if (options.relay) capabilities.push("relay");
+      const capabilities = (card.capabilities ?? []).map((capability) => ({
+        id: capability,
+        name: capability,
+        description: `Capability: ${capability}`
+      }));
+      if (options.relay) {
+        capabilities.push({
+          id: "relay",
+          name: "relay",
+          description: "Provides circuit relay service for NAT traversal"
+        });
+      }
       const agentCard = createAgentCard(
         identity3.did,
         card.name,
@@ -118377,9 +118415,19 @@ function registerJoinCommand(program2) {
           }
         }
       }, 3e4);
+      const verifyFn = async (signature, data) => {
+        try {
+          const decoded = JSON.parse(new TextDecoder().decode(data));
+          if (!decoded.from || typeof decoded.from !== "string") return false;
+          const senderPublicKey = extractPublicKey(decoded.from);
+          return verify(signature, data, senderPublicKey);
+        } catch {
+          return false;
+        }
+      };
       const router = createMessageRouter(
         node.libp2p,
-        async () => true,
+        verifyFn,
         dht
       );
       const messageHandler = async (envelope) => {
@@ -118610,9 +118658,19 @@ function registerSendCommand(program2) {
       spin.text = "Connecting to network...";
       await identifyDone;
       const dht = createDHTOperations(node.libp2p);
+      const verifyFn = async (signature, data) => {
+        try {
+          const decoded = JSON.parse(new TextDecoder().decode(data));
+          if (!decoded.from || typeof decoded.from !== "string") return false;
+          const senderPublicKey = extractPublicKey(decoded.from);
+          return verify(signature, data, senderPublicKey);
+        } catch {
+          return false;
+        }
+      };
       const router = createMessageRouter(
         node.libp2p,
-        async () => true,
+        verifyFn,
         dht,
         bootstrapPeers
       );