@gethashd/bytecave-browser 1.0.12 → 1.0.15

package/AGENTS.md

@@ -31,45 +31,47 @@ yarn build
 - `dist/react/index.js` - React-specific exports
 - `dist/*.d.ts` - TypeScript type definitions
 
-## **CRITICAL: Git Workflow**
+## **CRITICAL: npm Publishing Workflow**
 
 ### After Making Changes
 **YOU MUST FOLLOW THIS WORKFLOW:**
 
-1. **Build the package**
+1. **Build and publish to npm**
    ```bash
+   cd bytecave-browser
    yarn build
+   npm publish --access public
    ```
+   - This automatically builds, commits to git, and publishes to npm registry
+   - Version is controlled in `package.json`
 
-2. **Commit changes to git**
-   ```bash
-   git add .
-   git commit -m "Description of changes"
-   ```
-
-3. **Push to git**
-   ```bash
-   git push
-   ```
-
-4. **Update dependent packages**
+2. **Update dependent packages**
    In `web/` or `dashboard/`:
    ```bash
-   yarn upgrade @hashd/bytecave-browser
+   yarn upgrade @gethashd/bytecave-browser@<version>
    ```
+   - Use specific version number from `package.json`
+   - Example: `yarn upgrade @gethashd/bytecave-browser@1.0.13`
 
 ### Why This Is Critical
-- `web` and `dashboard` install bytecave-browser from **git**, not from local files
-- If you don't push to git, dependent packages will use stale code
-- Even after rebuilding, changes won't appear until pushed and upgraded
+- `web` and `dashboard` install bytecave-browser from **npm registry**, not from git
+- If you don't publish to npm, dependent packages will use stale code
+- Even after rebuilding locally, changes won't appear until published and upgraded
 
 ### Common Mistake
 ❌ **WRONG**: Build bytecave-browser → Rebuild web/dashboard → Test
-- This will use OLD code because web/dashboard pull from git
+- This will use OLD code because web/dashboard pull from npm
 
-✅ **CORRECT**: Build bytecave-browser → Git commit & push → Upgrade in web/dashboard → Test
+✅ **CORRECT**: Build & publish to npm → Upgrade in web/dashboard → Test
 - This ensures latest code is used
 
+### Version Management
+- Bump version in `package.json` before publishing
+- Follow semantic versioning: MAJOR.MINOR.PATCH
+- Patch (1.0.x): Bug fixes
+- Minor (1.x.0): New features, backward compatible
+- Major (x.0.0): Breaking changes
+
 ## Key Architecture Concepts
 
 ### ByteCaveClient
@@ -98,20 +100,20 @@ Main client class for P2P storage operations:
 
 ### Web App (`/web`)
 - Uses bytecave-browser for vault storage
-- Installs from git: `@hashd/bytecave-browser`
-- After bytecave-browser changes: `yarn upgrade @hashd/bytecave-browser`
+- Installs from npm: `@gethashd/bytecave-browser`
+- After bytecave-browser changes: `yarn upgrade @gethashd/bytecave-browser@<version>`
 
 ### Dashboard (`/dashboard`)
 - Uses bytecave-browser for test storage
-- Installs from git: `@hashd/bytecave-browser`
-- After bytecave-browser changes: `yarn upgrade @hashd/bytecave-browser`
+- Installs from npm: `@gethashd/bytecave-browser`
+- After bytecave-browser changes: `yarn upgrade @gethashd/bytecave-browser@<version>`
 
 ## Testing Workflow
 
 ### After Code Changes
-1. Build: `yarn build`
-2. Commit and push to git
-3. In web/dashboard: `yarn upgrade @hashd/bytecave-browser`
+1. Bump version in `package.json`
+2. Build and publish: `yarn build && npm publish --access public`
+3. In web/dashboard: `yarn upgrade @gethashd/bytecave-browser@<version>`
 4. Rebuild web/dashboard: `yarn build`
 5. Hard refresh browser (Cmd+Shift+R) to clear cache
 6. Test storage functionality
@@ -121,9 +123,9 @@ Main client class for P2P storage operations:
 #### Stale Code in Web/Dashboard
 **Symptom**: Changes to bytecave-browser don't appear in web/dashboard
 **Solution**: 
-1. Verify bytecave-browser was pushed to git
-2. Run `yarn upgrade @hashd/bytecave-browser` in web/dashboard
-3. Check `node_modules/@hashd/bytecave-browser/package.json` version/commit
+1. Verify bytecave-browser was published to npm (check version on npmjs.com)
+2. Run `yarn upgrade @gethashd/bytecave-browser@<version>` in web/dashboard
+3. Check `node_modules/@gethashd/bytecave-browser/package.json` version matches
 4. Hard refresh browser
 
 #### Type Errors After Changes

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

@@ -6120,12 +6120,43 @@ var ByteCaveClient = class {
               }
             });
             await Promise.allSettled(peerPromises);
+          } else {
+            console.log("[ByteCave] Relay returned 0 peers, trying direct addresses from localStorage...");
+            if (this.config.directNodeAddrs && this.config.directNodeAddrs.length > 0) {
+              console.log("[ByteCave] Attempting direct connections to", this.config.directNodeAddrs.length, "cached peers...");
+              for (const addr of this.config.directNodeAddrs) {
+                try {
+                  console.log("[ByteCave] Dialing direct address:", addr.slice(0, 60) + "...");
+                  const ma = multiaddr(addr);
+                  await this.node.dial(ma);
+                  console.log("[ByteCave] \u2713 Connected directly to peer");
+                } catch (dialErr) {
+                  console.warn("[ByteCave] Direct dial failed:", dialErr.message);
+                }
+              }
+            } else {
+              console.log("[ByteCave] No direct addresses in localStorage");
+            }
           }
         } catch (err) {
-          console.warn("[ByteCave] HTTP relay discovery failed, falling back to P2P directory:", err.message);
+          console.warn("[ByteCave] HTTP relay discovery failed:", err.message);
+          if (this.config.directNodeAddrs && this.config.directNodeAddrs.length > 0) {
+            console.log("[ByteCave] Attempting direct connections to cached peers...");
+            for (const addr of this.config.directNodeAddrs) {
+              try {
+                console.log("[ByteCave] Dialing direct address:", addr.slice(0, 60) + "...");
+                const ma = multiaddr(addr);
+                await this.node.dial(ma);
+                console.log("[ByteCave] \u2713 Connected directly to peer");
+              } catch (dialErr) {
+                console.warn("[ByteCave] Direct dial failed:", dialErr.message);
+              }
+            }
+          }
         }
       }
       console.log("[ByteCave] Querying relay for peer directory via P2P...");
+      let gotPeersFromDirectory = false;
       for (const relayAddr of bootstrapPeers) {
         try {
           const parts = relayAddr.split("/p2p/");
@@ -6134,6 +6165,7 @@ var ByteCaveClient = class {
           const directory = await p2pProtocolClient.getPeerDirectoryFromRelay(relayPeerId);
           if (directory && directory.peers.length > 0) {
             console.log("[ByteCave] Got", directory.peers.length, "peers from relay directory");
+            gotPeersFromDirectory = true;
             for (const peer of directory.peers) {
               try {
                 console.log("[ByteCave] Dialing peer from directory:", peer.peerId.slice(0, 12) + "...");
@@ -6175,6 +6207,23 @@ var ByteCaveClient = class {
           console.warn("[ByteCave] Failed to get directory from relay:", err.message);
         }
       }
+      if (!gotPeersFromDirectory && this.knownPeers.size === 0) {
+        if (this.config.directNodeAddrs && this.config.directNodeAddrs.length > 0) {
+          console.log("[ByteCave] No peers from relay, attempting direct connections to", this.config.directNodeAddrs.length, "cached peers...");
+          for (const addr of this.config.directNodeAddrs) {
+            try {
+              console.log("[ByteCave] Dialing direct address:", addr.slice(0, 60) + "...");
+              const ma = multiaddr(addr);
+              await this.node.dial(ma);
+              console.log("[ByteCave] \u2713 Connected directly to peer");
+            } catch (dialErr) {
+              console.warn("[ByteCave] Direct dial failed:", dialErr.message);
+            }
+          }
+        } else {
+          console.log("[ByteCave] No direct addresses in localStorage and no relay available");
+        }
+      }
       this.setConnectionState("connected");
       console.log("[ByteCave] Client started", {
         peerId: this.node.peerId.toString(),

package/dist/index.cjs

@@ -6173,12 +6173,43 @@ var ByteCaveClient = class {
               }
             });
             await Promise.allSettled(peerPromises);
+          } else {
+            console.log("[ByteCave] Relay returned 0 peers, trying direct addresses from localStorage...");
+            if (this.config.directNodeAddrs && this.config.directNodeAddrs.length > 0) {
+              console.log("[ByteCave] Attempting direct connections to", this.config.directNodeAddrs.length, "cached peers...");
+              for (const addr of this.config.directNodeAddrs) {
+                try {
+                  console.log("[ByteCave] Dialing direct address:", addr.slice(0, 60) + "...");
+                  const ma = (0, import_multiaddr.multiaddr)(addr);
+                  await this.node.dial(ma);
+                  console.log("[ByteCave] \u2713 Connected directly to peer");
+                } catch (dialErr) {
+                  console.warn("[ByteCave] Direct dial failed:", dialErr.message);
+                }
+              }
+            } else {
+              console.log("[ByteCave] No direct addresses in localStorage");
+            }
           }
         } catch (err) {
-          console.warn("[ByteCave] HTTP relay discovery failed, falling back to P2P directory:", err.message);
+          console.warn("[ByteCave] HTTP relay discovery failed:", err.message);
+          if (this.config.directNodeAddrs && this.config.directNodeAddrs.length > 0) {
+            console.log("[ByteCave] Attempting direct connections to cached peers...");
+            for (const addr of this.config.directNodeAddrs) {
+              try {
+                console.log("[ByteCave] Dialing direct address:", addr.slice(0, 60) + "...");
+                const ma = (0, import_multiaddr.multiaddr)(addr);
+                await this.node.dial(ma);
+                console.log("[ByteCave] \u2713 Connected directly to peer");
+              } catch (dialErr) {
+                console.warn("[ByteCave] Direct dial failed:", dialErr.message);
+              }
+            }
+          }
         }
       }
       console.log("[ByteCave] Querying relay for peer directory via P2P...");
+      let gotPeersFromDirectory = false;
       for (const relayAddr of bootstrapPeers) {
         try {
           const parts = relayAddr.split("/p2p/");
@@ -6187,6 +6218,7 @@ var ByteCaveClient = class {
           const directory = await p2pProtocolClient.getPeerDirectoryFromRelay(relayPeerId);
           if (directory && directory.peers.length > 0) {
             console.log("[ByteCave] Got", directory.peers.length, "peers from relay directory");
+            gotPeersFromDirectory = true;
             for (const peer of directory.peers) {
               try {
                 console.log("[ByteCave] Dialing peer from directory:", peer.peerId.slice(0, 12) + "...");
@@ -6228,6 +6260,23 @@ var ByteCaveClient = class {
           console.warn("[ByteCave] Failed to get directory from relay:", err.message);
         }
       }
+      if (!gotPeersFromDirectory && this.knownPeers.size === 0) {
+        if (this.config.directNodeAddrs && this.config.directNodeAddrs.length > 0) {
+          console.log("[ByteCave] No peers from relay, attempting direct connections to", this.config.directNodeAddrs.length, "cached peers...");
+          for (const addr of this.config.directNodeAddrs) {
+            try {
+              console.log("[ByteCave] Dialing direct address:", addr.slice(0, 60) + "...");
+              const ma = (0, import_multiaddr.multiaddr)(addr);
+              await this.node.dial(ma);
+              console.log("[ByteCave] \u2713 Connected directly to peer");
+            } catch (dialErr) {
+              console.warn("[ByteCave] Direct dial failed:", dialErr.message);
+            }
+          }
+        } else {
+          console.log("[ByteCave] No direct addresses in localStorage and no relay available");
+        }
+      }
       this.setConnectionState("connected");
       console.log("[ByteCave] Client started", {
         peerId: this.node.peerId.toString(),

package/dist/index.js

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

package/dist/react/index.js

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

package/package.json

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

package/src/client.ts

@@ -192,14 +192,48 @@ export class ByteCaveClient {
             
             // Wait for all peer connections and health queries to complete
             await Promise.allSettled(peerPromises);
+          } else {
+            // Relay returned 0 peers - try direct addresses from localStorage
+            console.log('[ByteCave] Relay returned 0 peers, trying direct addresses from localStorage...');
+            if (this.config.directNodeAddrs && this.config.directNodeAddrs.length > 0) {
+              console.log('[ByteCave] Attempting direct connections to', this.config.directNodeAddrs.length, 'cached peers...');
+              for (const addr of this.config.directNodeAddrs) {
+                try {
+                  console.log('[ByteCave] Dialing direct address:', addr.slice(0, 60) + '...');
+                  const ma = multiaddr(addr);
+                  await this.node!.dial(ma as any);
+                  console.log('[ByteCave] ✓ Connected directly to peer');
+                } catch (dialErr: any) {
+                  console.warn('[ByteCave] Direct dial failed:', dialErr.message);
+                }
+              }
+            } else {
+              console.log('[ByteCave] No direct addresses in localStorage');
+            }
           }
         } catch (err: any) {
-          console.warn('[ByteCave] HTTP relay discovery failed, falling back to P2P directory:', err.message);
+          console.warn('[ByteCave] HTTP relay discovery failed:', err.message);
+          
+          // Fallback: Try direct node addresses from localStorage
+          if (this.config.directNodeAddrs && this.config.directNodeAddrs.length > 0) {
+            console.log('[ByteCave] Attempting direct connections to cached peers...');
+            for (const addr of this.config.directNodeAddrs) {
+              try {
+                console.log('[ByteCave] Dialing direct address:', addr.slice(0, 60) + '...');
+                const ma = multiaddr(addr);
+                await this.node!.dial(ma as any);
+                console.log('[ByteCave] ✓ Connected directly to peer');
+              } catch (dialErr: any) {
+                console.warn('[ByteCave] Direct dial failed:', dialErr.message);
+              }
+            }
+          }
         }
       }
 
       // Fallback: Query relay for peer directory via P2P protocol
       console.log('[ByteCave] Querying relay for peer directory via P2P...');
+      let gotPeersFromDirectory = false;
       for (const relayAddr of bootstrapPeers) {
         try {
           // Extract relay peer ID from multiaddr
@@ -210,6 +244,7 @@ export class ByteCaveClient {
           const directory = await p2pProtocolClient.getPeerDirectoryFromRelay(relayPeerId);
           if (directory && directory.peers.length > 0) {
             console.log('[ByteCave] Got', directory.peers.length, 'peers from relay directory');
+            gotPeersFromDirectory = true;
             
             // Dial each peer and fetch health data
             for (const peer of directory.peers) {
@@ -260,6 +295,25 @@ export class ByteCaveClient {
         }
       }
 
+      // Final fallback: If no peers from relay (HTTP or P2P), try direct addresses
+      if (!gotPeersFromDirectory && this.knownPeers.size === 0) {
+        if (this.config.directNodeAddrs && this.config.directNodeAddrs.length > 0) {
+          console.log('[ByteCave] No peers from relay, attempting direct connections to', this.config.directNodeAddrs.length, 'cached peers...');
+          for (const addr of this.config.directNodeAddrs) {
+            try {
+              console.log('[ByteCave] Dialing direct address:', addr.slice(0, 60) + '...');
+              const ma = multiaddr(addr);
+              await this.node!.dial(ma as any);
+              console.log('[ByteCave] ✓ Connected directly to peer');
+            } catch (dialErr: any) {
+              console.warn('[ByteCave] Direct dial failed:', dialErr.message);
+            }
+          }
+        } else {
+          console.log('[ByteCave] No direct addresses in localStorage and no relay available');
+        }
+      }
+
       this.setConnectionState('connected');
       console.log('[ByteCave] Client started', {
         peerId: this.node.peerId.toString(),