@gethashd/bytecave-browser 1.0.52 → 1.0.54

package/dist/{chunk-XPZKBTJA.js → chunk-DKRX4RFS.js}

@@ -6616,6 +6616,9 @@ var ByteCaveClient = class {
         connectedPeers: connectedPeers.length,
         discoveredPeers: this.knownPeers.size
       });
+      setTimeout(() => {
+        this.dialCachedPeers();
+      }, 2e3);
     } catch (error) {
       this.setConnectionState("error");
       console.error("Failed to start ByteCave client:", error);
@@ -7146,8 +7149,57 @@ Nonce: ${nonce}`;
     };
     this.knownPeers.set(announcement.peerId, peerInfo);
     this.saveCachedPeers();
+    if (this.node && !peerInfo.connected) {
+      this.dialPeer(announcement.peerId, peerInfo.relayAddrs, peerInfo.multiaddrs).catch((err) => {
+        console.warn("[ByteCave] Failed to dial announced peer:", err.message);
+      });
+    }
     this.emit("peerAnnounce", peerInfo);
   }
+  /**
+   * Attempt to dial a peer using relay or WebTransport addresses
+   */
+  async dialPeer(peerId, relayAddrs, multiaddrs) {
+    if (!this.node) return;
+    const connections = this.node.getConnections().filter((c) => c.remotePeer.toString() === peerId);
+    if (connections.length > 0) {
+      console.log("[ByteCave] Already connected to peer:", peerId.slice(0, 12));
+      return;
+    }
+    console.log("[ByteCave] Attempting to dial peer:", peerId.slice(0, 12));
+    if (relayAddrs && relayAddrs.length > 0) {
+      console.log("[ByteCave] Trying relay address:", relayAddrs[0].slice(0, 60));
+      try {
+        const ma = multiaddr(relayAddrs[0]);
+        await this.node.dial(ma);
+        console.log("[ByteCave] \u2713 Connected via relay");
+        const peer = this.knownPeers.get(peerId);
+        if (peer) {
+          peer.connected = true;
+        }
+        return;
+      } catch (error) {
+        console.warn("[ByteCave] Relay dial failed:", error.message);
+      }
+    }
+    if (multiaddrs && multiaddrs.length > 0) {
+      const wtAddr = multiaddrs.find((addr) => addr.includes("/webtransport"));
+      if (wtAddr) {
+        console.log("[ByteCave] Trying WebTransport address:", wtAddr.slice(0, 60));
+        try {
+          const ma = multiaddr(wtAddr);
+          await this.node.dial(ma);
+          console.log("[ByteCave] \u2713 Connected via WebTransport");
+          const peer = this.knownPeers.get(peerId);
+          if (peer) {
+            peer.connected = true;
+          }
+        } catch (error) {
+          console.warn("[ByteCave] WebTransport dial failed:", error.message);
+        }
+      }
+    }
+  }
   /**
    * Load cached peers from localStorage
    */
@@ -7165,6 +7217,25 @@ Nonce: ${nonce}`;
       console.warn("[ByteCave] Failed to load cached peers:", error);
     }
   }
+  /**
+   * Dial all cached peers (used on startup when relay might be down)
+   */
+  async dialCachedPeers() {
+    console.log("[ByteCave] Dialing", this.knownPeers.size, "cached peers...");
+    for (const [peerId, peerInfo] of this.knownPeers) {
+      if (peerInfo.connected) {
+        continue;
+      }
+      const relayAddrs = peerInfo.relayAddrs;
+      const multiaddrs = peerInfo.multiaddrs;
+      if (relayAddrs || multiaddrs) {
+        this.dialPeer(peerId, relayAddrs, multiaddrs).catch((err) => {
+          console.warn("[ByteCave] Failed to dial cached peer:", peerId.slice(0, 12), err.message);
+        });
+        await new Promise((resolve) => setTimeout(resolve, 500));
+      }
+    }
+  }
   /**
    * Save known peers to localStorage
    */

package/dist/client.d.ts

@@ -98,10 +98,18 @@ export declare class ByteCaveClient {
     private setupEventListeners;
     private setupPubsub;
     private handlePeerAnnouncement;
+    /**
+     * Attempt to dial a peer using relay or WebTransport addresses
+     */
+    private dialPeer;
     /**
      * Load cached peers from localStorage
      */
     private loadCachedPeers;
+    /**
+     * Dial all cached peers (used on startup when relay might be down)
+     */
+    private dialCachedPeers;
     /**
      * Save known peers to localStorage
      */

package/dist/index.cjs

@@ -6669,6 +6669,9 @@ var ByteCaveClient = class {
         connectedPeers: connectedPeers.length,
         discoveredPeers: this.knownPeers.size
       });
+      setTimeout(() => {
+        this.dialCachedPeers();
+      }, 2e3);
     } catch (error) {
       this.setConnectionState("error");
       console.error("Failed to start ByteCave client:", error);
@@ -7199,8 +7202,57 @@ Nonce: ${nonce}`;
     };
     this.knownPeers.set(announcement.peerId, peerInfo);
     this.saveCachedPeers();
+    if (this.node && !peerInfo.connected) {
+      this.dialPeer(announcement.peerId, peerInfo.relayAddrs, peerInfo.multiaddrs).catch((err) => {
+        console.warn("[ByteCave] Failed to dial announced peer:", err.message);
+      });
+    }
     this.emit("peerAnnounce", peerInfo);
   }
+  /**
+   * Attempt to dial a peer using relay or WebTransport addresses
+   */
+  async dialPeer(peerId, relayAddrs, multiaddrs) {
+    if (!this.node) return;
+    const connections = this.node.getConnections().filter((c) => c.remotePeer.toString() === peerId);
+    if (connections.length > 0) {
+      console.log("[ByteCave] Already connected to peer:", peerId.slice(0, 12));
+      return;
+    }
+    console.log("[ByteCave] Attempting to dial peer:", peerId.slice(0, 12));
+    if (relayAddrs && relayAddrs.length > 0) {
+      console.log("[ByteCave] Trying relay address:", relayAddrs[0].slice(0, 60));
+      try {
+        const ma = (0, import_multiaddr.multiaddr)(relayAddrs[0]);
+        await this.node.dial(ma);
+        console.log("[ByteCave] \u2713 Connected via relay");
+        const peer = this.knownPeers.get(peerId);
+        if (peer) {
+          peer.connected = true;
+        }
+        return;
+      } catch (error) {
+        console.warn("[ByteCave] Relay dial failed:", error.message);
+      }
+    }
+    if (multiaddrs && multiaddrs.length > 0) {
+      const wtAddr = multiaddrs.find((addr) => addr.includes("/webtransport"));
+      if (wtAddr) {
+        console.log("[ByteCave] Trying WebTransport address:", wtAddr.slice(0, 60));
+        try {
+          const ma = (0, import_multiaddr.multiaddr)(wtAddr);
+          await this.node.dial(ma);
+          console.log("[ByteCave] \u2713 Connected via WebTransport");
+          const peer = this.knownPeers.get(peerId);
+          if (peer) {
+            peer.connected = true;
+          }
+        } catch (error) {
+          console.warn("[ByteCave] WebTransport dial failed:", error.message);
+        }
+      }
+    }
+  }
   /**
    * Load cached peers from localStorage
    */
@@ -7218,6 +7270,25 @@ Nonce: ${nonce}`;
       console.warn("[ByteCave] Failed to load cached peers:", error);
     }
   }
+  /**
+   * Dial all cached peers (used on startup when relay might be down)
+   */
+  async dialCachedPeers() {
+    console.log("[ByteCave] Dialing", this.knownPeers.size, "cached peers...");
+    for (const [peerId, peerInfo] of this.knownPeers) {
+      if (peerInfo.connected) {
+        continue;
+      }
+      const relayAddrs = peerInfo.relayAddrs;
+      const multiaddrs = peerInfo.multiaddrs;
+      if (relayAddrs || multiaddrs) {
+        this.dialPeer(peerId, relayAddrs, multiaddrs).catch((err) => {
+          console.warn("[ByteCave] Failed to dial cached peer:", peerId.slice(0, 12), err.message);
+        });
+        await new Promise((resolve) => setTimeout(resolve, 500));
+      }
+    }
+  }
   /**
    * Save known peers to localStorage
    */

package/dist/index.js

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

package/dist/react/index.js

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

package/package.json

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

package/src/client.ts

@@ -334,6 +334,11 @@ export class ByteCaveClient {
         discoveredPeers: this.knownPeers.size
       });
 
+      // Dial cached peers after startup (important when relay is down)
+      setTimeout(() => {
+        this.dialCachedPeers();
+      }, 2000); // Wait 2s for node to fully initialize
+
     } catch (error) {
       this.setConnectionState('error');
       console.error('Failed to start ByteCave client:', error);
@@ -995,8 +1000,71 @@ Nonce: ${nonce}`;
     this.knownPeers.set(announcement.peerId, peerInfo);
     this.saveCachedPeers();
 
+    // Attempt to dial the peer if not already connected
+    if (this.node && !peerInfo.connected) {
+      this.dialPeer(announcement.peerId, peerInfo.relayAddrs, peerInfo.multiaddrs).catch(err => {
+        console.warn('[ByteCave] Failed to dial announced peer:', err.message);
+      });
+    }
+
     this.emit('peerAnnounce', peerInfo);
   }
+
+  /**
+   * Attempt to dial a peer using relay or WebTransport addresses
+   */
+  private async dialPeer(peerId: string, relayAddrs?: string[], multiaddrs?: string[]): Promise<void> {
+    if (!this.node) return;
+
+    // Check if already connected
+    const connections = this.node.getConnections().filter(c => c.remotePeer.toString() === peerId);
+    if (connections.length > 0) {
+      console.log('[ByteCave] Already connected to peer:', peerId.slice(0, 12));
+      return;
+    }
+
+    console.log('[ByteCave] Attempting to dial peer:', peerId.slice(0, 12));
+
+    // Try relay first
+    if (relayAddrs && relayAddrs.length > 0) {
+      console.log('[ByteCave] Trying relay address:', relayAddrs[0].slice(0, 60));
+      try {
+        const ma = multiaddr(relayAddrs[0]);
+        await this.node.dial(ma as any);
+        console.log('[ByteCave] ✓ Connected via relay');
+        
+        // Update connected status
+        const peer = this.knownPeers.get(peerId);
+        if (peer) {
+          peer.connected = true;
+        }
+        return;
+      } catch (error: any) {
+        console.warn('[ByteCave] Relay dial failed:', error.message);
+      }
+    }
+
+    // Fallback to WebTransport
+    if (multiaddrs && multiaddrs.length > 0) {
+      const wtAddr = multiaddrs.find((addr: string) => addr.includes('/webtransport'));
+      if (wtAddr) {
+        console.log('[ByteCave] Trying WebTransport address:', wtAddr.slice(0, 60));
+        try {
+          const ma = multiaddr(wtAddr);
+          await this.node.dial(ma as any);
+          console.log('[ByteCave] ✓ Connected via WebTransport');
+          
+          // Update connected status
+          const peer = this.knownPeers.get(peerId);
+          if (peer) {
+            peer.connected = true;
+          }
+        } catch (error: any) {
+          console.warn('[ByteCave] WebTransport dial failed:', error.message);
+        }
+      }
+    }
+  }
   
 
   /**
@@ -1017,6 +1085,32 @@ Nonce: ${nonce}`;
     }
   }
 
+  /**
+   * Dial all cached peers (used on startup when relay might be down)
+   */
+  private async dialCachedPeers(): Promise<void> {
+    console.log('[ByteCave] Dialing', this.knownPeers.size, 'cached peers...');
+    
+    for (const [peerId, peerInfo] of this.knownPeers) {
+      // Skip if already connected
+      if (peerInfo.connected) {
+        continue;
+      }
+
+      const relayAddrs = (peerInfo as any).relayAddrs;
+      const multiaddrs = peerInfo.multiaddrs;
+
+      if (relayAddrs || multiaddrs) {
+        this.dialPeer(peerId, relayAddrs, multiaddrs).catch(err => {
+          console.warn('[ByteCave] Failed to dial cached peer:', peerId.slice(0, 12), err.message);
+        });
+        
+        // Stagger dials to avoid overwhelming the network
+        await new Promise(resolve => setTimeout(resolve, 500));
+      }
+    }
+  }
+
   /**
    * Save known peers to localStorage
    */