@gethashd/bytecave-browser 1.0.11 → 1.0.12

package/dist/{chunk-P4WRAVTF.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);

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);

package/dist/index.js

@@ -13,7 +13,7 @@ import {
   useHashdImage,
   useHashdMedia,
   useHashdUrl
-} from "./chunk-P4WRAVTF.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-P4WRAVTF.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.11",
+  "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);