@gethashd/bytecave-browser 1.0.26 → 1.0.28

package/dist/{chunk-XMU2N2NN.js → chunk-OV4Q3HIT.js}

@@ -5726,41 +5726,57 @@ var P2PProtocolClient = class {
         } catch (e) {
           console.warn("[ByteCave P2P] Could not get peer info from peerStore:", e);
         }
-        console.log("[ByteCave P2P] Step 2: Dialing store protocol /bytecave/store/1.0.0...");
-        const dialStart = Date.now();
-        let stream;
-        let lastError;
-        for (let attempt = 1; attempt <= 3; attempt++) {
-          try {
-            console.log(`[ByteCave P2P] Dial attempt ${attempt}/3...`);
-            stream = await this.node.dialProtocol(peerIdObj, "/bytecave/store/1.0.0");
-            const dialDuration = Date.now() - dialStart;
-            console.log("[ByteCave P2P] Step 3: Stream established in", dialDuration, "ms");
-            console.log("[ByteCave P2P] Stream details:", {
-              protocol: stream.protocol,
-              direction: stream.direction,
-              timeline: stream.timeline
-            });
-            break;
-          } catch (dialError) {
-            lastError = dialError;
-            const dialDuration = Date.now() - dialStart;
-            console.warn(`[ByteCave P2P] Dial attempt ${attempt} failed after ${dialDuration}ms:`, dialError.message);
-            if (attempt < 3) {
-              console.log("[ByteCave P2P] Waiting 1s before retry (node may still be registering handlers)...");
-              await new Promise((resolve) => setTimeout(resolve, 1e3));
-            }
+        console.log("[ByteCave P2P] Step 2: Checking if connection upgrade needed...");
+        if (existingConns.length === 0) {
+          throw new Error("No connection to peer - cannot open protocol stream");
+        }
+        let connection = existingConns[0];
+        const isRelayCircuit = connection.remoteAddr.toString().includes("/p2p-circuit");
+        console.log("[ByteCave P2P] Connection type:", isRelayCircuit ? "relay circuit (limited)" : "direct");
+        console.log("[ByteCave P2P] Connection address:", connection.remoteAddr.toString());
+        if (isRelayCircuit) {
+          console.log("[ByteCave P2P] Waiting for DCUtR to upgrade relay circuit to direct WebRTC...");
+          const upgradeStart = Date.now();
+          const hasDirectConnection = await this.waitForDirectConnection(peerId, 5e3);
+          const upgradeDuration = Date.now() - upgradeStart;
+          if (!hasDirectConnection) {
+            console.error("[ByteCave P2P] DCUtR upgrade failed after", upgradeDuration, "ms");
+            throw new Error("Cannot use storage protocol - relay circuit upgrade to WebRTC failed");
           }
+          console.log("[ByteCave P2P] DCUtR upgrade successful after", upgradeDuration, "ms");
+          const directConns = this.node.getConnections(peerIdObj);
+          const directConn = directConns.find((conn) => !conn.remoteAddr.toString().includes("/p2p-circuit"));
+          if (!directConn) {
+            throw new Error("DCUtR reported success but no direct connection found");
+          }
+          connection = directConn;
+          console.log("[ByteCave P2P] Using direct connection:", connection.remoteAddr.toString());
         }
-        if (!stream) {
-          const dialDuration = Date.now() - dialStart;
-          console.error("[ByteCave P2P] All dial attempts FAILED after", dialDuration, "ms:", {
-            error: lastError.message,
-            code: lastError.code,
-            name: lastError.name,
-            stack: lastError.stack?.split("\n").slice(0, 3)
+        console.log("[ByteCave P2P] Step 3: Opening protocol stream...");
+        const streamStart = Date.now();
+        let stream;
+        try {
+          console.log("[ByteCave P2P] Calling connection.newStream with protocol /bytecave/store/1.0.0...");
+          stream = await connection.newStream("/bytecave/store/1.0.0");
+          const streamDuration = Date.now() - streamStart;
+          console.log("[ByteCave P2P] Step 4: Protocol stream opened in", streamDuration, "ms");
+          console.log("[ByteCave P2P] Stream details:", {
+            protocol: stream.protocol,
+            direction: stream.direction,
+            id: stream.id,
+            timeline: stream.timeline
+          });
+        } catch (streamError) {
+          const streamDuration = Date.now() - streamStart;
+          console.error("[ByteCave P2P] Failed to open protocol stream after", streamDuration, "ms:", {
+            error: streamError.message,
+            code: streamError.code,
+            name: streamError.name,
+            connectionStatus: connection.status,
+            connectionStreams: connection.streams.length,
+            stack: streamError.stack?.split("\n").slice(0, 3)
           });
-          throw lastError;
+          throw streamError;
         }
         const dataCopy = new Uint8Array(ciphertext);
         const hashBuffer = await crypto.subtle.digest("SHA-256", dataCopy);

package/dist/index.cjs

@@ -5794,41 +5794,57 @@ var P2PProtocolClient = class {
         } catch (e) {
           console.warn("[ByteCave P2P] Could not get peer info from peerStore:", e);
         }
-        console.log("[ByteCave P2P] Step 2: Dialing store protocol /bytecave/store/1.0.0...");
-        const dialStart = Date.now();
-        let stream;
-        let lastError;
-        for (let attempt = 1; attempt <= 3; attempt++) {
-          try {
-            console.log(`[ByteCave P2P] Dial attempt ${attempt}/3...`);
-            stream = await this.node.dialProtocol(peerIdObj, "/bytecave/store/1.0.0");
-            const dialDuration = Date.now() - dialStart;
-            console.log("[ByteCave P2P] Step 3: Stream established in", dialDuration, "ms");
-            console.log("[ByteCave P2P] Stream details:", {
-              protocol: stream.protocol,
-              direction: stream.direction,
-              timeline: stream.timeline
-            });
-            break;
-          } catch (dialError) {
-            lastError = dialError;
-            const dialDuration = Date.now() - dialStart;
-            console.warn(`[ByteCave P2P] Dial attempt ${attempt} failed after ${dialDuration}ms:`, dialError.message);
-            if (attempt < 3) {
-              console.log("[ByteCave P2P] Waiting 1s before retry (node may still be registering handlers)...");
-              await new Promise((resolve) => setTimeout(resolve, 1e3));
-            }
+        console.log("[ByteCave P2P] Step 2: Checking if connection upgrade needed...");
+        if (existingConns.length === 0) {
+          throw new Error("No connection to peer - cannot open protocol stream");
+        }
+        let connection = existingConns[0];
+        const isRelayCircuit = connection.remoteAddr.toString().includes("/p2p-circuit");
+        console.log("[ByteCave P2P] Connection type:", isRelayCircuit ? "relay circuit (limited)" : "direct");
+        console.log("[ByteCave P2P] Connection address:", connection.remoteAddr.toString());
+        if (isRelayCircuit) {
+          console.log("[ByteCave P2P] Waiting for DCUtR to upgrade relay circuit to direct WebRTC...");
+          const upgradeStart = Date.now();
+          const hasDirectConnection = await this.waitForDirectConnection(peerId, 5e3);
+          const upgradeDuration = Date.now() - upgradeStart;
+          if (!hasDirectConnection) {
+            console.error("[ByteCave P2P] DCUtR upgrade failed after", upgradeDuration, "ms");
+            throw new Error("Cannot use storage protocol - relay circuit upgrade to WebRTC failed");
           }
+          console.log("[ByteCave P2P] DCUtR upgrade successful after", upgradeDuration, "ms");
+          const directConns = this.node.getConnections(peerIdObj);
+          const directConn = directConns.find((conn) => !conn.remoteAddr.toString().includes("/p2p-circuit"));
+          if (!directConn) {
+            throw new Error("DCUtR reported success but no direct connection found");
+          }
+          connection = directConn;
+          console.log("[ByteCave P2P] Using direct connection:", connection.remoteAddr.toString());
         }
-        if (!stream) {
-          const dialDuration = Date.now() - dialStart;
-          console.error("[ByteCave P2P] All dial attempts FAILED after", dialDuration, "ms:", {
-            error: lastError.message,
-            code: lastError.code,
-            name: lastError.name,
-            stack: lastError.stack?.split("\n").slice(0, 3)
+        console.log("[ByteCave P2P] Step 3: Opening protocol stream...");
+        const streamStart = Date.now();
+        let stream;
+        try {
+          console.log("[ByteCave P2P] Calling connection.newStream with protocol /bytecave/store/1.0.0...");
+          stream = await connection.newStream("/bytecave/store/1.0.0");
+          const streamDuration = Date.now() - streamStart;
+          console.log("[ByteCave P2P] Step 4: Protocol stream opened in", streamDuration, "ms");
+          console.log("[ByteCave P2P] Stream details:", {
+            protocol: stream.protocol,
+            direction: stream.direction,
+            id: stream.id,
+            timeline: stream.timeline
+          });
+        } catch (streamError) {
+          const streamDuration = Date.now() - streamStart;
+          console.error("[ByteCave P2P] Failed to open protocol stream after", streamDuration, "ms:", {
+            error: streamError.message,
+            code: streamError.code,
+            name: streamError.name,
+            connectionStatus: connection.status,
+            connectionStreams: connection.streams.length,
+            stack: streamError.stack?.split("\n").slice(0, 3)
           });
-          throw lastError;
+          throw streamError;
         }
         const dataCopy = new Uint8Array(ciphertext);
         const hashBuffer = await crypto.subtle.digest("SHA-256", dataCopy);

package/dist/index.js

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

package/dist/react/index.cjs

@@ -6049,41 +6049,57 @@ var P2PProtocolClient = class {
         } catch (e) {
           console.warn("[ByteCave P2P] Could not get peer info from peerStore:", e);
         }
-        console.log("[ByteCave P2P] Step 2: Dialing store protocol /bytecave/store/1.0.0...");
-        const dialStart = Date.now();
-        let stream;
-        let lastError;
-        for (let attempt = 1; attempt <= 3; attempt++) {
-          try {
-            console.log(`[ByteCave P2P] Dial attempt ${attempt}/3...`);
-            stream = await this.node.dialProtocol(peerIdObj, "/bytecave/store/1.0.0");
-            const dialDuration = Date.now() - dialStart;
-            console.log("[ByteCave P2P] Step 3: Stream established in", dialDuration, "ms");
-            console.log("[ByteCave P2P] Stream details:", {
-              protocol: stream.protocol,
-              direction: stream.direction,
-              timeline: stream.timeline
-            });
-            break;
-          } catch (dialError) {
-            lastError = dialError;
-            const dialDuration = Date.now() - dialStart;
-            console.warn(`[ByteCave P2P] Dial attempt ${attempt} failed after ${dialDuration}ms:`, dialError.message);
-            if (attempt < 3) {
-              console.log("[ByteCave P2P] Waiting 1s before retry (node may still be registering handlers)...");
-              await new Promise((resolve) => setTimeout(resolve, 1e3));
-            }
+        console.log("[ByteCave P2P] Step 2: Checking if connection upgrade needed...");
+        if (existingConns.length === 0) {
+          throw new Error("No connection to peer - cannot open protocol stream");
+        }
+        let connection = existingConns[0];
+        const isRelayCircuit = connection.remoteAddr.toString().includes("/p2p-circuit");
+        console.log("[ByteCave P2P] Connection type:", isRelayCircuit ? "relay circuit (limited)" : "direct");
+        console.log("[ByteCave P2P] Connection address:", connection.remoteAddr.toString());
+        if (isRelayCircuit) {
+          console.log("[ByteCave P2P] Waiting for DCUtR to upgrade relay circuit to direct WebRTC...");
+          const upgradeStart = Date.now();
+          const hasDirectConnection = await this.waitForDirectConnection(peerId, 5e3);
+          const upgradeDuration = Date.now() - upgradeStart;
+          if (!hasDirectConnection) {
+            console.error("[ByteCave P2P] DCUtR upgrade failed after", upgradeDuration, "ms");
+            throw new Error("Cannot use storage protocol - relay circuit upgrade to WebRTC failed");
           }
+          console.log("[ByteCave P2P] DCUtR upgrade successful after", upgradeDuration, "ms");
+          const directConns = this.node.getConnections(peerIdObj);
+          const directConn = directConns.find((conn) => !conn.remoteAddr.toString().includes("/p2p-circuit"));
+          if (!directConn) {
+            throw new Error("DCUtR reported success but no direct connection found");
+          }
+          connection = directConn;
+          console.log("[ByteCave P2P] Using direct connection:", connection.remoteAddr.toString());
         }
-        if (!stream) {
-          const dialDuration = Date.now() - dialStart;
-          console.error("[ByteCave P2P] All dial attempts FAILED after", dialDuration, "ms:", {
-            error: lastError.message,
-            code: lastError.code,
-            name: lastError.name,
-            stack: lastError.stack?.split("\n").slice(0, 3)
+        console.log("[ByteCave P2P] Step 3: Opening protocol stream...");
+        const streamStart = Date.now();
+        let stream;
+        try {
+          console.log("[ByteCave P2P] Calling connection.newStream with protocol /bytecave/store/1.0.0...");
+          stream = await connection.newStream("/bytecave/store/1.0.0");
+          const streamDuration = Date.now() - streamStart;
+          console.log("[ByteCave P2P] Step 4: Protocol stream opened in", streamDuration, "ms");
+          console.log("[ByteCave P2P] Stream details:", {
+            protocol: stream.protocol,
+            direction: stream.direction,
+            id: stream.id,
+            timeline: stream.timeline
+          });
+        } catch (streamError) {
+          const streamDuration = Date.now() - streamStart;
+          console.error("[ByteCave P2P] Failed to open protocol stream after", streamDuration, "ms:", {
+            error: streamError.message,
+            code: streamError.code,
+            name: streamError.name,
+            connectionStatus: connection.status,
+            connectionStreams: connection.streams.length,
+            stack: streamError.stack?.split("\n").slice(0, 3)
           });
-          throw lastError;
+          throw streamError;
         }
         const dataCopy = new Uint8Array(ciphertext);
         const hashBuffer = await crypto.subtle.digest("SHA-256", dataCopy);

package/dist/react/index.js

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

package/package.json

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

package/src/p2p-protocols.ts

@@ -148,46 +148,68 @@ export class P2PProtocolClient {
           console.warn('[ByteCave P2P] Could not get peer info from peerStore:', e);
         }
         
-        // Step 2: Dial store protocol with retry (node may need time to register handlers after startup)
-        console.log('[ByteCave P2P] Step 2: Dialing store protocol /bytecave/store/1.0.0...');
-        const dialStart = Date.now();
-        let stream;
-        let lastError;
+        // Step 2: Wait for connection upgrade from limited relay circuit to full WebRTC
+        console.log('[ByteCave P2P] Step 2: Checking if connection upgrade needed...');
+        
+        if (existingConns.length === 0) {
+          throw new Error('No connection to peer - cannot open protocol stream');
+        }
         
-        // Retry up to 3 times with 1s delay - gives node time to register protocol handlers
-        for (let attempt = 1; attempt <= 3; attempt++) {
-          try {
-            console.log(`[ByteCave P2P] Dial attempt ${attempt}/3...`);
-            stream = await this.node!.dialProtocol(peerIdObj, '/bytecave/store/1.0.0');
-            const dialDuration = Date.now() - dialStart;
-            console.log('[ByteCave P2P] Step 3: Stream established in', dialDuration, 'ms');
-            console.log('[ByteCave P2P] Stream details:', {
-              protocol: stream.protocol,
-              direction: stream.direction,
-              timeline: stream.timeline
-            });
-            break; // Success!
-          } catch (dialError: any) {
-            lastError = dialError;
-            const dialDuration = Date.now() - dialStart;
-            console.warn(`[ByteCave P2P] Dial attempt ${attempt} failed after ${dialDuration}ms:`, dialError.message);
-            
-            if (attempt < 3) {
-              console.log('[ByteCave P2P] Waiting 1s before retry (node may still be registering handlers)...');
-              await new Promise(resolve => setTimeout(resolve, 1000));
-            }
+        let connection = existingConns[0];
+        const isRelayCircuit = connection.remoteAddr.toString().includes('/p2p-circuit');
+        console.log('[ByteCave P2P] Connection type:', isRelayCircuit ? 'relay circuit (limited)' : 'direct');
+        console.log('[ByteCave P2P] Connection address:', connection.remoteAddr.toString());
+        
+        // If it's a relay circuit, wait for DCUtR to upgrade to direct WebRTC
+        if (isRelayCircuit) {
+          console.log('[ByteCave P2P] Waiting for DCUtR to upgrade relay circuit to direct WebRTC...');
+          const upgradeStart = Date.now();
+          const hasDirectConnection = await this.waitForDirectConnection(peerId, 5000);
+          const upgradeDuration = Date.now() - upgradeStart;
+          
+          if (!hasDirectConnection) {
+            console.error('[ByteCave P2P] DCUtR upgrade failed after', upgradeDuration, 'ms');
+            throw new Error('Cannot use storage protocol - relay circuit upgrade to WebRTC failed');
           }
+          
+          console.log('[ByteCave P2P] DCUtR upgrade successful after', upgradeDuration, 'ms');
+          
+          // Get the new direct connection
+          const directConns = this.node!.getConnections(peerIdObj);
+          const directConn = directConns.find(conn => !conn.remoteAddr.toString().includes('/p2p-circuit'));
+          if (!directConn) {
+            throw new Error('DCUtR reported success but no direct connection found');
+          }
+          connection = directConn;
+          console.log('[ByteCave P2P] Using direct connection:', connection.remoteAddr.toString());
         }
         
-        if (!stream) {
-          const dialDuration = Date.now() - dialStart;
-          console.error('[ByteCave P2P] All dial attempts FAILED after', dialDuration, 'ms:', {
-            error: lastError.message,
-            code: lastError.code,
-            name: lastError.name,
-            stack: lastError.stack?.split('\n').slice(0, 3)
+        // Step 3: Open protocol stream on the connection
+        console.log('[ByteCave P2P] Step 3: Opening protocol stream...');
+        const streamStart = Date.now();
+        let stream;
+        try {
+          console.log('[ByteCave P2P] Calling connection.newStream with protocol /bytecave/store/1.0.0...');
+          stream = await connection.newStream('/bytecave/store/1.0.0');
+          const streamDuration = Date.now() - streamStart;
+          console.log('[ByteCave P2P] Step 4: Protocol stream opened in', streamDuration, 'ms');
+          console.log('[ByteCave P2P] Stream details:', {
+            protocol: stream.protocol,
+            direction: stream.direction,
+            id: stream.id,
+            timeline: stream.timeline
+          });
+        } catch (streamError: any) {
+          const streamDuration = Date.now() - streamStart;
+          console.error('[ByteCave P2P] Failed to open protocol stream after', streamDuration, 'ms:', {
+            error: streamError.message,
+            code: streamError.code,
+            name: streamError.name,
+            connectionStatus: connection.status,
+            connectionStreams: connection.streams.length,
+            stack: streamError.stack?.split('\n').slice(0, 3)
           });
-          throw lastError;
+          throw streamError;
         }
 
         // Generate CID using SHA-256 (matches bytecave-core format: 64-char hex)