magnetk 2.2.5 → 2.3.0

package/client.js

@@ -62,19 +62,30 @@ DISCOVERY_PRIORITY=dht,relay,direct
 
 # ===== Chunking =====
 CHUNK_SIZE_MB=1
+ADAPTIVE_CHUNKING=true
 MAX_PARALLEL_CHUNKS=10
+
+# ===== Connection Strategy =====
+# RELAY_ASSISTED: auto | true | false
+#   auto  = try direct P2P first, fall back to relay if unreachable
+#   true  = always route data through relay (privacy mode)
+#   false = direct P2P only, fail if unreachable
+RELAY_ASSISTED=auto
+# HOLE_PUNCH: Enable NAT traversal via STUN + libp2p hole punching
+HOLE_PUNCH=true
+# RELAY_TIMEOUT_MS: How long to wait for direct connection before relay fallback
+RELAY_TIMEOUT_MS=5000
 `;
 
 export class MagnetkClient extends EventEmitter {
     constructor(config = {}) {
         super();
         this.config = {
-            // Relay settings (supports multiple relays for failover)
+            // Relay settings (supports multiple relays for failover/scaling)
             relayUrl: '69.169.109.243',
             relayPort: 4003,
             relays: [],           // Array of {host, port} for multi-relay failover
             seedPort: 4002,
-            enableSTUN: true,
             seederPath: null,
             configPath: null,
 
@@ -83,6 +94,13 @@ export class MagnetkClient extends EventEmitter {
             dhtBootstrapPeers: [],         // Custom bootstrap peer multiaddrs
             discoveryPriority: ['dht', 'relay', 'direct'], // Discovery order
 
+            // Connection strategy
+            stunServers: ['stun:stun.l.google.com:19302'],  // STUN servers for NAT traversal
+            holePunch: true,               // Enable NAT hole punching (STUN first, relay fallback)
+            relayAssisted: 'auto',         // 'auto' | true | false — relay-assisted data transfer
+            enableRelayFallback: true,     // Fall back to relay if direct P2P fails
+            relayTimeout: 5000,            // ms to wait for direct connection before relay fallback
+
             // Auto-config: create settings.conf if missing
             autoConfig: true,
             ...config
@@ -307,6 +325,23 @@ export class MagnetkClient extends EventEmitter {
             args.push('-bootstrap', this.config.dhtBootstrapPeers.join(','));
         }
 
+        // Connection strategy flags
+        if (this.config.holePunch) {
+            args.push('-holepunch');
+        }
+        if (this.config.relayAssisted !== undefined) {
+            const mode = this.config.relayAssisted === true ? 'true'
+                : this.config.relayAssisted === false ? 'false'
+                    : this.config.relayAssisted;
+            args.push('-relay-assisted', mode);
+        }
+
+        // Multi-relay: pass additional relay addresses
+        if (this.config.relays && this.config.relays.length > 0) {
+            const relayAddrs = this.config.relays.map(r => `${r.host}:${r.port}`).join(',');
+            args.push('-relay-addresses', relayAddrs);
+        }
+
         console.log(`[Magnetk-JS] Spawning seeder: ${binPath} ${args.join(' ')}`);
 
         return new Promise((resolve, reject) => {
@@ -391,21 +426,68 @@ export class MagnetkClient extends EventEmitter {
         }
 
         const addressesToTry = [];
+
+        // Helper: filter out non-routable addresses
+        const isRoutable = (host) => {
+            if (!host) return false;
+            // 0.0.0.0 is a bind-all address, not valid for connecting
+            if (host === '0.0.0.0') return false;
+            // Link-local, loopback handled separately
+            if (host.startsWith('169.254.')) return false;
+            return true;
+        };
+
         if (lookupResult && lookupResult.found && lookupResult.seeds.length > 0) {
             const seed = lookupResult.seeds[0];
-            if (seed.transport_addr) addressesToTry.push(seed.transport_addr);
+            console.log(`[Magnetk-JS] Relay returned seed: peer_id=${seed.peer_id}, transport_addr=${seed.transport_addr}, addresses=${JSON.stringify(seed.addresses)}`);
+
+            // Add transport_addr if routable
+            if (seed.transport_addr) {
+                const [h] = seed.transport_addr.split(':');
+                if (isRoutable(h)) {
+                    addressesToTry.push(seed.transport_addr);
+                } else {
+                    console.log(`[Magnetk-JS] Skipping non-routable transport_addr: ${seed.transport_addr}`);
+                }
+            }
+
+            // Parse multiaddr addresses
             if (seed.addresses) {
                 seed.addresses.forEach(addr => {
                     const parts = addr.split('/');
                     if (parts.length >= 5 && parts[1] === 'ip4' && parts[3] === 'tcp') {
-                        addressesToTry.push(`${parts[2]}:${parts[4]}`);
+                        const ip = parts[2];
+                        if (isRoutable(ip)) {
+                            addressesToTry.push(`${ip}:${parts[4]}`);
+                        } else {
+                            console.log(`[Magnetk-JS] Skipping non-routable address: ${addr}`);
+                        }
                     }
                 });
             }
+        } else {
+            console.log(`[Magnetk-JS] Relay lookup: no seeds found for this file hash`);
         }
+
+        // Fallback: extract seed IP from magnet link relay addr
+        // If the magnet link contains the relay multiaddr, the seed's IP might be known
+        // from the relay's host (when seed is on same VPS as relay)
+        if (addressesToTry.length === 0 && ml.relayAddr) {
+            // Try to parse /ip4/HOST/tcp/PORT from relay multiaddr
+            const parts = ml.relayAddr.split('/');
+            if (parts.length >= 3 && parts[1] === 'ip4') {
+                const seedAddr = `${parts[2]}:${this.config.seedPort}`;
+                console.log(`[Magnetk-JS] No routable seeds from relay, trying relay host as seed: ${seedAddr}`);
+                addressesToTry.push(seedAddr);
+            }
+        }
+
+        // Local fallback (same machine)
         addressesToTry.push(`127.0.0.1:${this.config.seedPort}`);
 
         const uniqueAddrs = [...new Set(addressesToTry)];
+        console.log(`[Magnetk-JS] Connection attempts: ${uniqueAddrs.join(', ')}`);
+
         let socket;
         let connectionType = CONNECTION_TYPE.UNKNOWN;
         let finalAddr = null;
@@ -415,7 +497,11 @@ export class MagnetkClient extends EventEmitter {
             const port = parseInt(portStr, 10) || 4002;
 
             try {
-                socket = await this.connect(host, port);
+                // Use configurable timeout for connection attempts
+                socket = await Promise.race([
+                    this.connect(host, port),
+                    new Promise((_, reject) => setTimeout(() => reject(new Error('timeout')), this.config.relayTimeout || 5000))
+                ]);
                 finalAddr = addr;
                 if (host === '127.0.0.1' || host === 'localhost') connectionType = CONNECTION_TYPE.LOCAL;
                 else if (host === relayHost) connectionType = CONNECTION_TYPE.RELAYED;

package/download.js

@@ -19,7 +19,7 @@ async function download() {
         dhtEnabled: true, // Enable DHT discovery
         relayUrl: '69.169.109.243',
         relayPort: 4003,
-        seedPort: 4005
+        seedPort: 4002
     });
 
     // Extract filename from URI roughly to show intention

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "magnetk",
-  "version": "2.2.5",
+  "version": "2.3.0",
   "description": "JavaScript SDK for Magnetk P2P File Transfer System",
   "main": "index.js",
   "bin": {
@@ -34,4 +34,4 @@
   ],
   "author": "Magnetk Contributors",
   "license": "MIT"
-}
+}

package/share.js

@@ -1,6 +1,6 @@
-import { MagnetkClient } from 'magnetk';
+import { MagnetkClient } from './client.js';
 import path from 'path';
-import 'dotenv/config';
+// import 'dotenv/config';
 
 const filePath = "./app.txt";
 
@@ -8,8 +8,8 @@ async function share() {
     const client = new MagnetkClient({
         relayUrl: '69.169.109.243', // Default to local for dev, change to public IPs for prod
         relayPort: 4003,
-        seederPath: process.env.MAGNETK_SEEDER_PATH,
-        seedPort: 4005 // Default seed port
+        // seederPath: process.env.MAGNETK_SEEDER_PATH || "~root/Desktop/Magnetk/magnetk/bin/seed",
+        seedPort: 4002 // Data transfer port (must not conflict with relay 4003)
     });
 
     console.log(`[Share] Preparing to share: ${filePath}`);