@gethashd/bytecave-browser 1.0.23 → 1.0.25

package/dist/{chunk-VICLADDD.js → chunk-MVXA47HN.js}

@@ -5705,14 +5705,58 @@ var P2PProtocolClient = class {
       const timeoutMs = 3e4 + fileSizeMB * 1e4;
       console.log(`[ByteCave P2P] Store timeout: ${Math.round(timeoutMs / 1e3)}s for ${fileSizeMB.toFixed(2)}MB`);
       const storePromise = (async () => {
-        console.log("[ByteCave P2P] Step 1: Dialing store protocol...");
-        const stream = await this.node.dialProtocol(peerIdObj, "/bytecave/store/1.0.0");
-        console.log("[ByteCave P2P] Step 2: Stream established");
+        console.log("[ByteCave P2P] Step 1: Checking existing connections to peer", peerId.slice(0, 12));
+        const existingConns = this.node.getConnections(peerIdObj);
+        console.log("[ByteCave P2P] Existing connections:", existingConns.length);
+        existingConns.forEach((conn, idx) => {
+          console.log(`[ByteCave P2P] Connection ${idx}:`, {
+            remoteAddr: conn.remoteAddr.toString(),
+            status: conn.status,
+            direction: conn.direction,
+            timeline: conn.timeline
+          });
+        });
+        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));
+            }
+          }
+        }
+        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)
+          });
+          throw lastError;
+        }
         const dataCopy = new Uint8Array(ciphertext);
         const hashBuffer = await crypto.subtle.digest("SHA-256", dataCopy);
         const hashArray = Array.from(new Uint8Array(hashBuffer));
         const cid = hashArray.map((b) => b.toString(16).padStart(2, "0")).join("");
-        console.log("[ByteCave P2P] Step 3: CID generated:", cid.slice(0, 16) + "...");
+        console.log("[ByteCave P2P] Step 5: CID generated:", cid.slice(0, 16) + "...");
         const request = {
           cid,
           mimeType,
@@ -5723,13 +5767,20 @@ var P2PProtocolClient = class {
           timestamp: authorization?.timestamp || Date.now(),
           authorization
         };
-        console.log("[ByteCave P2P] Step 4: Request prepared, size:", JSON.stringify(request).length, "bytes");
-        console.log("[ByteCave P2P] Step 5: Writing message to stream...");
+        console.log("[ByteCave P2P] Step 5: Request prepared, size:", JSON.stringify(request).length, "bytes");
+        console.log("[ByteCave P2P] Step 6: Writing message to stream...");
+        const writeStart = Date.now();
         await this.writeMessage(stream, request);
-        console.log("[ByteCave P2P] Step 6: Message written, waiting for response...");
+        const writeDuration = Date.now() - writeStart;
+        console.log("[ByteCave P2P] Request written in", writeDuration, "ms");
+        console.log("[ByteCave P2P] Step 7: Waiting for response from node...");
+        const readStart = Date.now();
         const response = await this.readMessage(stream);
-        console.log("[ByteCave P2P] Step 7: Response received:", response);
+        const readDuration = Date.now() - readStart;
+        console.log("[ByteCave P2P] Response received in", readDuration, "ms:", response);
+        console.log("[ByteCave P2P] Step 8: Closing stream...");
         await stream.close();
+        console.log("[ByteCave P2P] Stream closed successfully");
         if (response?.success) {
           return { success: true, cid };
         } else {

package/dist/index.cjs

@@ -5773,14 +5773,58 @@ var P2PProtocolClient = class {
       const timeoutMs = 3e4 + fileSizeMB * 1e4;
       console.log(`[ByteCave P2P] Store timeout: ${Math.round(timeoutMs / 1e3)}s for ${fileSizeMB.toFixed(2)}MB`);
       const storePromise = (async () => {
-        console.log("[ByteCave P2P] Step 1: Dialing store protocol...");
-        const stream = await this.node.dialProtocol(peerIdObj, "/bytecave/store/1.0.0");
-        console.log("[ByteCave P2P] Step 2: Stream established");
+        console.log("[ByteCave P2P] Step 1: Checking existing connections to peer", peerId.slice(0, 12));
+        const existingConns = this.node.getConnections(peerIdObj);
+        console.log("[ByteCave P2P] Existing connections:", existingConns.length);
+        existingConns.forEach((conn, idx) => {
+          console.log(`[ByteCave P2P] Connection ${idx}:`, {
+            remoteAddr: conn.remoteAddr.toString(),
+            status: conn.status,
+            direction: conn.direction,
+            timeline: conn.timeline
+          });
+        });
+        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));
+            }
+          }
+        }
+        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)
+          });
+          throw lastError;
+        }
         const dataCopy = new Uint8Array(ciphertext);
         const hashBuffer = await crypto.subtle.digest("SHA-256", dataCopy);
         const hashArray = Array.from(new Uint8Array(hashBuffer));
         const cid = hashArray.map((b) => b.toString(16).padStart(2, "0")).join("");
-        console.log("[ByteCave P2P] Step 3: CID generated:", cid.slice(0, 16) + "...");
+        console.log("[ByteCave P2P] Step 5: CID generated:", cid.slice(0, 16) + "...");
         const request = {
           cid,
           mimeType,
@@ -5791,13 +5835,20 @@ var P2PProtocolClient = class {
           timestamp: authorization?.timestamp || Date.now(),
           authorization
         };
-        console.log("[ByteCave P2P] Step 4: Request prepared, size:", JSON.stringify(request).length, "bytes");
-        console.log("[ByteCave P2P] Step 5: Writing message to stream...");
+        console.log("[ByteCave P2P] Step 5: Request prepared, size:", JSON.stringify(request).length, "bytes");
+        console.log("[ByteCave P2P] Step 6: Writing message to stream...");
+        const writeStart = Date.now();
         await this.writeMessage(stream, request);
-        console.log("[ByteCave P2P] Step 6: Message written, waiting for response...");
+        const writeDuration = Date.now() - writeStart;
+        console.log("[ByteCave P2P] Request written in", writeDuration, "ms");
+        console.log("[ByteCave P2P] Step 7: Waiting for response from node...");
+        const readStart = Date.now();
         const response = await this.readMessage(stream);
-        console.log("[ByteCave P2P] Step 7: Response received:", response);
+        const readDuration = Date.now() - readStart;
+        console.log("[ByteCave P2P] Response received in", readDuration, "ms:", response);
+        console.log("[ByteCave P2P] Step 8: Closing stream...");
         await stream.close();
+        console.log("[ByteCave P2P] Stream closed successfully");
         if (response?.success) {
           return { success: true, cid };
         } else {

package/dist/index.js

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

package/dist/react/index.cjs

@@ -6028,14 +6028,58 @@ var P2PProtocolClient = class {
       const timeoutMs = 3e4 + fileSizeMB * 1e4;
       console.log(`[ByteCave P2P] Store timeout: ${Math.round(timeoutMs / 1e3)}s for ${fileSizeMB.toFixed(2)}MB`);
       const storePromise = (async () => {
-        console.log("[ByteCave P2P] Step 1: Dialing store protocol...");
-        const stream = await this.node.dialProtocol(peerIdObj, "/bytecave/store/1.0.0");
-        console.log("[ByteCave P2P] Step 2: Stream established");
+        console.log("[ByteCave P2P] Step 1: Checking existing connections to peer", peerId.slice(0, 12));
+        const existingConns = this.node.getConnections(peerIdObj);
+        console.log("[ByteCave P2P] Existing connections:", existingConns.length);
+        existingConns.forEach((conn, idx) => {
+          console.log(`[ByteCave P2P] Connection ${idx}:`, {
+            remoteAddr: conn.remoteAddr.toString(),
+            status: conn.status,
+            direction: conn.direction,
+            timeline: conn.timeline
+          });
+        });
+        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));
+            }
+          }
+        }
+        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)
+          });
+          throw lastError;
+        }
         const dataCopy = new Uint8Array(ciphertext);
         const hashBuffer = await crypto.subtle.digest("SHA-256", dataCopy);
         const hashArray = Array.from(new Uint8Array(hashBuffer));
         const cid = hashArray.map((b) => b.toString(16).padStart(2, "0")).join("");
-        console.log("[ByteCave P2P] Step 3: CID generated:", cid.slice(0, 16) + "...");
+        console.log("[ByteCave P2P] Step 5: CID generated:", cid.slice(0, 16) + "...");
         const request = {
           cid,
           mimeType,
@@ -6046,13 +6090,20 @@ var P2PProtocolClient = class {
           timestamp: authorization?.timestamp || Date.now(),
           authorization
         };
-        console.log("[ByteCave P2P] Step 4: Request prepared, size:", JSON.stringify(request).length, "bytes");
-        console.log("[ByteCave P2P] Step 5: Writing message to stream...");
+        console.log("[ByteCave P2P] Step 5: Request prepared, size:", JSON.stringify(request).length, "bytes");
+        console.log("[ByteCave P2P] Step 6: Writing message to stream...");
+        const writeStart = Date.now();
         await this.writeMessage(stream, request);
-        console.log("[ByteCave P2P] Step 6: Message written, waiting for response...");
+        const writeDuration = Date.now() - writeStart;
+        console.log("[ByteCave P2P] Request written in", writeDuration, "ms");
+        console.log("[ByteCave P2P] Step 7: Waiting for response from node...");
+        const readStart = Date.now();
         const response = await this.readMessage(stream);
-        console.log("[ByteCave P2P] Step 7: Response received:", response);
+        const readDuration = Date.now() - readStart;
+        console.log("[ByteCave P2P] Response received in", readDuration, "ms:", response);
+        console.log("[ByteCave P2P] Step 8: Closing stream...");
         await stream.close();
+        console.log("[ByteCave P2P] Stream closed successfully");
         if (response?.success) {
           return { success: true, cid };
         } else {

package/dist/react/index.js

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

package/package.json

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

package/src/p2p-protocols.ts

@@ -124,17 +124,66 @@ export class P2PProtocolClient {
       
       // Wrap the entire operation in a timeout
       const storePromise = (async () => {
-        console.log('[ByteCave P2P] Step 1: Dialing store protocol...');
-        // dialProtocol will upgrade limited relay connections to full connections automatically
-        const stream = await this.node!.dialProtocol(peerIdObj, '/bytecave/store/1.0.0');
-        console.log('[ByteCave P2P] Step 2: Stream established');
+        console.log('[ByteCave P2P] Step 1: Checking existing connections to peer', peerId.slice(0, 12));
+        const existingConns = this.node!.getConnections(peerIdObj);
+        console.log('[ByteCave P2P] Existing connections:', existingConns.length);
+        existingConns.forEach((conn, idx) => {
+          console.log(`[ByteCave P2P] Connection ${idx}:`, {
+            remoteAddr: conn.remoteAddr.toString(),
+            status: conn.status,
+            direction: conn.direction,
+            timeline: conn.timeline
+          });
+        });
+        
+        // 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;
+        
+        // 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));
+            }
+          }
+        }
+        
+        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)
+          });
+          throw lastError;
+        }
 
         // Generate CID using SHA-256 (matches bytecave-core format: 64-char hex)
         const dataCopy = new Uint8Array(ciphertext);
         const hashBuffer = await crypto.subtle.digest('SHA-256', dataCopy);
         const hashArray = Array.from(new Uint8Array(hashBuffer));
         const cid = hashArray.map(b => b.toString(16).padStart(2, '0')).join('');
-        console.log('[ByteCave P2P] Step 3: CID generated:', cid.slice(0, 16) + '...');
+        console.log('[ByteCave P2P] Step 5: CID generated:', cid.slice(0, 16) + '...');
 
         const request: StoreRequest = {
           cid,
@@ -146,15 +195,23 @@ export class P2PProtocolClient {
           timestamp: authorization?.timestamp || Date.now(),
           authorization
         };
-        console.log('[ByteCave P2P] Step 4: Request prepared, size:', JSON.stringify(request).length, 'bytes');
+        console.log('[ByteCave P2P] Step 5: Request prepared, size:', JSON.stringify(request).length, 'bytes');
 
-        console.log('[ByteCave P2P] Step 5: Writing message to stream...');
+        console.log('[ByteCave P2P] Step 6: Writing message to stream...');
+        const writeStart = Date.now();
         await this.writeMessage(stream, request);
-        console.log('[ByteCave P2P] Step 6: Message written, waiting for response...');
+        const writeDuration = Date.now() - writeStart;
+        console.log('[ByteCave P2P] Request written in', writeDuration, 'ms');
+        
+        console.log('[ByteCave P2P] Step 7: Waiting for response from node...');
+        const readStart = Date.now();
         const response = await this.readMessage<StoreResponse>(stream);
-        console.log('[ByteCave P2P] Step 7: Response received:', response);
+        const readDuration = Date.now() - readStart;
+        console.log('[ByteCave P2P] Response received in', readDuration, 'ms:', response);
 
+        console.log('[ByteCave P2P] Step 8: Closing stream...');
         await stream.close();
+        console.log('[ByteCave P2P] Stream closed successfully');
 
         if (response?.success) {
           return { success: true, cid };