@gethashd/bytecave-browser 1.0.10 → 1.0.12

package/dist/{chunk-DJDKXTUN.js → chunk-XC5Z2TQH.js}

@@ -5777,16 +5777,47 @@ var P2PProtocolClient = class {
       return null;
     }
   }
+  /**
+   * Wait for a direct (non-relay) connection to a peer
+   * Returns true if direct connection is available, false if timeout
+   */
+  async waitForDirectConnection(peerId, timeoutMs = 3e3) {
+    if (!this.node) return false;
+    const peerIdObj = peerIdFromString(peerId);
+    const startTime = Date.now();
+    while (Date.now() - startTime < timeoutMs) {
+      const connections = this.node.getConnections(peerIdObj);
+      const hasDirectConnection = connections.some((conn) => {
+        const isRelay = conn.remoteAddr.toString().includes("/p2p-circuit");
+        return !isRelay;
+      });
+      if (hasDirectConnection) {
+        console.log("[ByteCave P2P] Direct connection established to", peerId.slice(0, 12));
+        return true;
+      }
+      await new Promise((resolve) => setTimeout(resolve, 100));
+    }
+    console.warn("[ByteCave P2P] Timeout waiting for direct connection to", peerId.slice(0, 12));
+    return false;
+  }
   /**
    * Get health info from a peer via P2P stream
+   * Waits for direct connection upgrade before querying
    */
-  async getHealthFromPeer(peerId) {
+  async getHealthFromPeer(peerId, waitForDirect = true) {
     if (!this.node) {
       console.warn("[ByteCave P2P] No node available for health request");
       return null;
     }
     try {
       const peerIdObj = peerIdFromString(peerId);
+      if (waitForDirect) {
+        const hasDirect = await this.waitForDirectConnection(peerId, 3e3);
+        if (!hasDirect) {
+          console.warn("[ByteCave P2P] No direct connection available for health query to", peerId.slice(0, 12));
+          return null;
+        }
+      }
       const stream = await this.node.dialProtocol(peerIdObj, PROTOCOL_HEALTH);
       await this.writeMessage(stream, {});
       const response = await this.readMessage(stream);
@@ -6731,8 +6762,7 @@ function ByteCaveProvider({
         }
       };
       client.on("connectionStateChange", handleStateChange);
-      client.on("peerConnect", handlePeerUpdate);
-      client.on("peerDisconnect", handlePeerUpdate);
+      client.on("peerAnnounce", handlePeerUpdate);
       const hasPeers = directNodeAddrs.length > 0 || relayPeers.length > 0;
       console.log("[ByteCaveProvider] Auto-connect check:", {
         hasPeers,

package/dist/index.cjs

@@ -5845,16 +5845,47 @@ var P2PProtocolClient = class {
       return null;
     }
   }
+  /**
+   * Wait for a direct (non-relay) connection to a peer
+   * Returns true if direct connection is available, false if timeout
+   */
+  async waitForDirectConnection(peerId, timeoutMs = 3e3) {
+    if (!this.node) return false;
+    const peerIdObj = peerIdFromString(peerId);
+    const startTime = Date.now();
+    while (Date.now() - startTime < timeoutMs) {
+      const connections = this.node.getConnections(peerIdObj);
+      const hasDirectConnection = connections.some((conn) => {
+        const isRelay = conn.remoteAddr.toString().includes("/p2p-circuit");
+        return !isRelay;
+      });
+      if (hasDirectConnection) {
+        console.log("[ByteCave P2P] Direct connection established to", peerId.slice(0, 12));
+        return true;
+      }
+      await new Promise((resolve) => setTimeout(resolve, 100));
+    }
+    console.warn("[ByteCave P2P] Timeout waiting for direct connection to", peerId.slice(0, 12));
+    return false;
+  }
   /**
    * Get health info from a peer via P2P stream
+   * Waits for direct connection upgrade before querying
    */
-  async getHealthFromPeer(peerId) {
+  async getHealthFromPeer(peerId, waitForDirect = true) {
     if (!this.node) {
       console.warn("[ByteCave P2P] No node available for health request");
       return null;
     }
     try {
       const peerIdObj = peerIdFromString(peerId);
+      if (waitForDirect) {
+        const hasDirect = await this.waitForDirectConnection(peerId, 3e3);
+        if (!hasDirect) {
+          console.warn("[ByteCave P2P] No direct connection available for health query to", peerId.slice(0, 12));
+          return null;
+        }
+      }
       const stream = await this.node.dialProtocol(peerIdObj, PROTOCOL_HEALTH);
       await this.writeMessage(stream, {});
       const response = await this.readMessage(stream);
@@ -6784,8 +6815,7 @@ function ByteCaveProvider({
         }
       };
       client.on("connectionStateChange", handleStateChange);
-      client.on("peerConnect", handlePeerUpdate);
-      client.on("peerDisconnect", handlePeerUpdate);
+      client.on("peerAnnounce", handlePeerUpdate);
       const hasPeers = directNodeAddrs.length > 0 || relayPeers.length > 0;
       console.log("[ByteCaveProvider] Auto-connect check:", {
         hasPeers,

package/dist/index.js

@@ -13,7 +13,7 @@ import {
   useHashdImage,
   useHashdMedia,
   useHashdUrl
-} from "./chunk-DJDKXTUN.js";
+} from "./chunk-XC5Z2TQH.js";
 import {
   clearHashdCache,
   createHashdUrl,

package/dist/p2p-protocols.d.ts

@@ -90,10 +90,16 @@ export declare class P2PProtocolClient {
         data: Uint8Array;
         mimeType: string;
     } | null>;
+    /**
+     * Wait for a direct (non-relay) connection to a peer
+     * Returns true if direct connection is available, false if timeout
+     */
+    private waitForDirectConnection;
     /**
      * Get health info from a peer via P2P stream
+     * Waits for direct connection upgrade before querying
      */
-    getHealthFromPeer(peerId: string): Promise<P2PHealthResponse | null>;
+    getHealthFromPeer(peerId: string, waitForDirect?: boolean): Promise<P2PHealthResponse | null>;
     /**
      * Query relay for peer directory
      */

package/dist/react/index.cjs

@@ -6100,16 +6100,47 @@ var P2PProtocolClient = class {
       return null;
     }
   }
+  /**
+   * Wait for a direct (non-relay) connection to a peer
+   * Returns true if direct connection is available, false if timeout
+   */
+  async waitForDirectConnection(peerId, timeoutMs = 3e3) {
+    if (!this.node) return false;
+    const peerIdObj = peerIdFromString(peerId);
+    const startTime = Date.now();
+    while (Date.now() - startTime < timeoutMs) {
+      const connections = this.node.getConnections(peerIdObj);
+      const hasDirectConnection = connections.some((conn) => {
+        const isRelay = conn.remoteAddr.toString().includes("/p2p-circuit");
+        return !isRelay;
+      });
+      if (hasDirectConnection) {
+        console.log("[ByteCave P2P] Direct connection established to", peerId.slice(0, 12));
+        return true;
+      }
+      await new Promise((resolve) => setTimeout(resolve, 100));
+    }
+    console.warn("[ByteCave P2P] Timeout waiting for direct connection to", peerId.slice(0, 12));
+    return false;
+  }
   /**
    * Get health info from a peer via P2P stream
+   * Waits for direct connection upgrade before querying
    */
-  async getHealthFromPeer(peerId) {
+  async getHealthFromPeer(peerId, waitForDirect = true) {
     if (!this.node) {
       console.warn("[ByteCave P2P] No node available for health request");
       return null;
     }
     try {
       const peerIdObj = peerIdFromString(peerId);
+      if (waitForDirect) {
+        const hasDirect = await this.waitForDirectConnection(peerId, 3e3);
+        if (!hasDirect) {
+          console.warn("[ByteCave P2P] No direct connection available for health query to", peerId.slice(0, 12));
+          return null;
+        }
+      }
       const stream = await this.node.dialProtocol(peerIdObj, PROTOCOL_HEALTH);
       await this.writeMessage(stream, {});
       const response = await this.readMessage(stream);

package/dist/react/index.js

@@ -8,7 +8,7 @@ import {
   useHashdImage,
   useHashdMedia,
   useHashdUrl
-} from "../chunk-DJDKXTUN.js";
+} from "../chunk-XC5Z2TQH.js";
 import "../chunk-EEZWRIUI.js";
 export {
   HashdAudio,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gethashd/bytecave-browser",
-  "version": "1.0.10",
+  "version": "1.0.12",
   "description": "ByteCave browser client for WebRTC P2P connections to storage nodes",
   "main": "dist/index.cjs",
   "module": "dist/index.js",

package/src/p2p-protocols.ts

@@ -219,20 +219,59 @@ export class P2PProtocolClient {
     }
   }
 
+  /**
+   * Wait for a direct (non-relay) connection to a peer
+   * Returns true if direct connection is available, false if timeout
+   */
+  private async waitForDirectConnection(peerId: string, timeoutMs: number = 3000): Promise<boolean> {
+    if (!this.node) return false;
+    
+    const peerIdObj = peerIdFromString(peerId);
+    const startTime = Date.now();
+    
+    while (Date.now() - startTime < timeoutMs) {
+      const connections = this.node.getConnections(peerIdObj);
+      const hasDirectConnection = connections.some(conn => {
+        // Check if connection is NOT a relay circuit (direct WebRTC or WebSocket)
+        const isRelay = conn.remoteAddr.toString().includes('/p2p-circuit');
+        return !isRelay;
+      });
+      
+      if (hasDirectConnection) {
+        console.log('[ByteCave P2P] Direct connection established to', peerId.slice(0, 12));
+        return true;
+      }
+      
+      // Wait 100ms before checking again
+      await new Promise(resolve => setTimeout(resolve, 100));
+    }
+    
+    console.warn('[ByteCave P2P] Timeout waiting for direct connection to', peerId.slice(0, 12));
+    return false;
+  }
+
   /**
    * Get health info from a peer via P2P stream
+   * Waits for direct connection upgrade before querying
    */
-  async getHealthFromPeer(peerId: string): Promise<P2PHealthResponse | null> {
+  async getHealthFromPeer(peerId: string, waitForDirect: boolean = true): Promise<P2PHealthResponse | null> {
     if (!this.node) {
       console.warn('[ByteCave P2P] No node available for health request');
       return null;
     }
 
     try {
-      
       // Convert string peerId to PeerId object
       const peerIdObj = peerIdFromString(peerId);
       
+      // Wait for DCUtR to upgrade connection to direct WebRTC
+      if (waitForDirect) {
+        const hasDirect = await this.waitForDirectConnection(peerId, 3000);
+        if (!hasDirect) {
+          console.warn('[ByteCave P2P] No direct connection available for health query to', peerId.slice(0, 12));
+          return null;
+        }
+      }
 
       const stream = await this.node.dialProtocol(peerIdObj, PROTOCOL_HEALTH);
 

package/src/provider.tsx

@@ -141,8 +141,9 @@ export function ByteCaveProvider({
       };
 
       client.on('connectionStateChange', handleStateChange);
-      client.on('peerConnect', handlePeerUpdate);
-      client.on('peerDisconnect', handlePeerUpdate);
+      // Only listen to peerAnnounce - floodsub announcements are the single source of truth
+      // They include all health data (nodeId, storage, blobs, etc.)
+      client.on('peerAnnounce', handlePeerUpdate);
 
       const hasPeers = directNodeAddrs.length > 0 || relayPeers.length > 0;