magnetk 2.2.4 → 2.2.6

package/cli.js

@@ -1,4 +1,4 @@
-#!/usr/bin/env node
+#!/usr/bin/env node
 
 /**
  * Magnetk CLI
@@ -20,7 +20,9 @@ if (!command || command === '--help' || command === '-h' || command === 'help')
     process.exit(0);
 }
 
-const client = new MagnetkClient();
+const client = new MagnetkClient({
+    dhtEnabled: true // Enable DHT discovery
+});
 
 async function run() {
     try {

package/client.js

@@ -34,16 +34,75 @@ export const CONNECTION_TYPE = {
     UNKNOWN: 'UNKNOWN'
 };
 
+const DEFAULT_CONFIG_CONTENT = `# Magnetk P2P Configuration
+# Auto-generated by Magnetk JS SDK. Edit as needed.
+# All values are optional - defaults are used when not specified
+
+# ===== Network Binding =====
+BIND_ADDRESS=0.0.0.0
+DISCOVERY_PORT=4001
+TRANSPORT_PORT=4002
+LOCALHOST_MODE=false
+
+# ===== Relay =====
+RELAY_ADDRESS=0.0.0.0:4001
+
+# Multi-relay: comma-separated for failover/scaling
+# RELAY_ADDRESSES=
+
+# ===== DHT (Decentralized Discovery) =====
+DHT_ENABLED=false
+DHT_MODE=auto
+# Default: Public IPFS bootstrap nodes
+DHT_BOOTSTRAP_PEERS=/dnsaddr/bootstrap.libp2p.io/p2p/QmNnooDu7bfjPFoTZYxMNLWUQJyrVwtbZg5gBMjTezGAJN,/dnsaddr/bootstrap.libp2p.io/p2p/QmQCU2EcMqAqQPR2i9bChDtGNJchTbq5TbXJJ16u19uLTa,/dnsaddr/bootstrap.libp2p.io/p2p/QmbLHAnMoJPWSCR5Zhtx6BHJX9KiKNN6tpvbUcqanj75Nb,/dnsaddr/bootstrap.libp2p.io/p2p/QmcZf59bWwK5XFi76CZX8cbJ4BhTzzA3gU1ZjYZcYW3dwt,/ip4/104.131.131.82/tcp/4001/p2p/QmaCpDMGvV2BGHeYERUEnRQAwe3N8SzbUtfsmvsqQLuvuJ
+
+# ===== Discovery Priority =====
+# Order: dht, relay, direct (comma-separated)
+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/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,
+
+            // DHT settings
+            dhtEnabled: false,             // Enable DHT discovery
+            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
         };
         this.processes = [];
@@ -178,6 +237,32 @@ export class MagnetkClient extends EventEmitter {
         }
     }
 
+    /**
+     * Look up seeds with multi-relay failover.
+     * Tries each relay in order until one succeeds.
+     * @param {string} fileHash
+     * @returns {Promise<Object>}
+     */
+    async lookupPeerWithFailover(fileHash) {
+        // Build relay list: primary + configured relays
+        const relays = [
+            { host: this.config.relayUrl, port: this.config.relayPort },
+            ...this.config.relays
+        ];
+
+        let lastError = null;
+        for (const relay of relays) {
+            try {
+                const result = await this.lookupPeer(relay.host, relay.port, fileHash);
+                if (result && result.found) return result;
+            } catch (e) {
+                console.log(`[Magnetk-JS] Relay ${relay.host}:${relay.port} failed: ${e.message}`);
+                lastError = e;
+            }
+        }
+        throw lastError || new Error('All relays failed');
+    }
+
     /**
      * Seeds a file and returns a Magnetk link.
      * @param {string} filePath 
@@ -190,7 +275,6 @@ export class MagnetkClient extends EventEmitter {
         }
 
         this.emit('validating-relay');
-        // Simple reachability check (optional but good for UX)
 
         const fileStats = fs.statSync(absolutePath);
         this.emit('hashing', { percent: 0 });
@@ -221,12 +305,43 @@ export class MagnetkClient extends EventEmitter {
         }
 
         const args = [
-            '-relay', relayMultiaddr,
             '-file', absolutePath,
             '-port', this.config.seedPort.toString(),
             '-config', configPath
         ];
 
+        // Add relay if available
+        if (relayPeerId || this.config.relayUrl) {
+            args.push('-relay', relayMultiaddr);
+        }
+
+        // Add DHT if enabled
+        if (this.config.dhtEnabled) {
+            args.push('-dht');
+        }
+
+        // Add bootstrap peers if configured
+        if (this.config.dhtBootstrapPeers && this.config.dhtBootstrapPeers.length > 0) {
+            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) => {
@@ -251,10 +366,13 @@ export class MagnetkClient extends EventEmitter {
 
             seeder.stderr.on('data', (data) => {
                 const msg = data.toString();
-                console.log(`[Seeder Stderr] ${msg}`); // Uncommented for debug
+                console.log(`[Seeder Stderr] ${msg}`);
                 if (msg.includes('Connected to relay')) {
                     this.emit('relay-connected', { host: this.config.relayUrl, port: 4001 });
                 }
+                if (msg.includes('DHT') && msg.includes('announced')) {
+                    this.emit('dht-announced');
+                }
             });
 
             seeder.on('error', (err) => {
@@ -320,7 +438,7 @@ export class MagnetkClient extends EventEmitter {
                 });
             }
         }
-        addressesToTry.push('127.0.0.1:4002');
+        addressesToTry.push(`127.0.0.1:${this.config.seedPort}`);
 
         const uniqueAddrs = [...new Set(addressesToTry)];
         let socket;
@@ -392,11 +510,66 @@ export class MagnetkClient extends EventEmitter {
     }
 
     /**
-     * Finds available seeders for a hash.
+     * Finds available seeders for a hash (with multi-relay failover).
      */
     async lookupSeeds(fileHash) {
-        const result = await this.lookupPeer(this.config.relayUrl, this.config.relayPort, fileHash);
-        return result.found ? result.seeds : [];
+        try {
+            const result = await this.lookupPeerWithFailover(fileHash);
+            return result.found ? result.seeds : [];
+        } catch (e) {
+            return [];
+        }
+    }
+
+    // ═══════════════════════════════════════════════════
+    //  MINIMAL-CODE API (for SDK users writing less code)
+    // ═══════════════════════════════════════════════════
+
+    /**
+     * Share a file with one function call.
+     * Handles hashing, seeding, and returns the magnet link.
+     * 
+     * @example
+     * const link = await magnetk.share('./my-file.zip');
+     * console.log('Share this link:', link);
+     *
+     * @param {string} filePath - Path to the file to share
+     * @returns {Promise<string>} Magnet link
+     */
+    async share(filePath) {
+        return this.seed(filePath);
+    }
+
+    /**
+     * Download a file with one function call.
+     * Handles discovery, downloading, and verification.
+     * 
+     * @example
+     * await magnetk.get('magnetk:?xt=urn:sha256:abc...', './downloads/');
+     *
+     * @param {string} magnetURI - Magnet link to download
+     * @param {string} [outputPath] - Output directory or file path (default: current directory)
+     * @returns {Promise<string>} Path to the downloaded file
+     */
+    async get(magnetURI, outputPath) {
+        const ml = typeof magnetURI === 'string' ? MagnetkLink.parse(magnetURI) : magnetURI;
+        const output = outputPath || `./${ml.fileName}`;
+        await this.download(magnetURI, output);
+        return output;
+    }
+
+    /**
+     * Hash a file and return its SHA-256 hash.
+     * Useful when users want to pre-compute hashes.
+     * 
+     * @example
+     * const hash = await magnetk.hash('./my-file.zip');
+     * 
+     * @param {string} filePath
+     * @returns {Promise<string>} Hex-encoded SHA-256 hash
+     */
+    async hash(filePath) {
+        return this._calculateHash(path.resolve(filePath));
     }
 
     _calculateHash(filePath) {
@@ -433,7 +606,7 @@ export class MagnetkClient extends EventEmitter {
             if (fs.existsSync(p)) return p;
         }
 
-        return binName; // Fallback to PATH (e.g. "seed" or "seed.exe")
+        return binName; // Fallback to PATH
     }
 
     _resolveConfigPath() {
@@ -441,14 +614,31 @@ export class MagnetkClient extends EventEmitter {
         if (this.config.configPath) return this.config.configPath;
 
         // 2. Check local dev environment
-        const paths = [
+        const searchPaths = [
             path.join(process.cwd(), 'config', 'settings.conf'),
             path.join(process.cwd(), '..', '..', '..', 'config', 'settings.conf'),
             path.join(process.cwd(), '..', '..', 'config', 'settings.conf')
         ];
-        for (const p of paths) {
+        for (const p of searchPaths) {
             if (fs.existsSync(p)) return p;
         }
+
+        // 3. Auto-create settings.conf in current directory
+        if (this.config.autoConfig) {
+            const autoPath = path.join(process.cwd(), 'config', 'settings.conf');
+            try {
+                const configDir = path.dirname(autoPath);
+                if (!fs.existsSync(configDir)) {
+                    fs.mkdirSync(configDir, { recursive: true });
+                }
+                fs.writeFileSync(autoPath, DEFAULT_CONFIG_CONTENT);
+                console.log(`[Magnetk-JS] Created default config at ${autoPath}`);
+                return autoPath;
+            } catch (e) {
+                console.warn(`[Magnetk-JS] Could not auto-create config: ${e.message}`);
+            }
+        }
+
         return ''; // Let seeder use default
     }
 }

package/download.js

@@ -0,0 +1,95 @@
+import { MagnetkClient, CONNECTION_TYPE } from 'magnetk';
+import path from 'path';
+import os from 'os';
+
+// Parse command line arguments
+const args = process.argv.slice(2);
+if (args.length < 1) {
+    console.error('Usage: node download.js <magnetk_link>');
+    process.exit(1);
+}
+
+const magnetURI = args[0];
+
+// Determine Desktop Path
+const desktopPath = path.join(os.homedir(), '/OneDrive/Desktop');
+
+async function download() {
+    const client = new MagnetkClient({
+        dhtEnabled: true, // Enable DHT discovery
+        relayUrl: '69.169.109.243',
+        relayPort: 4003,
+        seedPort: 4002
+    });
+
+    // Extract filename from URI roughly to show intention
+    // In real download, client.download handles parsing
+    let intendedFilename = 'downloaded_file';
+    try {
+        const urlParams = new URL(magnetURI.replace('magnetk:', 'http://dummy.com')).searchParams;
+        if (urlParams.has('dn')) intendedFilename = urlParams.get('dn');
+    } catch (e) { }
+
+    const outputPath = path.join(desktopPath, intendedFilename);
+
+    console.log(`[Download] Initiating download for: ${magnetURI}`);
+    console.log(`[Download] Target: ${outputPath}`);
+
+    // Check Public Identity
+    try {
+        console.log('[Download] Resolving Public Identity (STUN)...');
+        const identity = await client.getPublicIdentity();
+        console.log(`[Download] Public Identity: ${identity.ip}:${identity.port}`);
+    } catch (e) {
+        console.warn(`[Download] STUN lookup failed: ${e.message}`);
+    }
+
+    // Progress Tracking
+    client.on('download-start', (info) => console.log(`[Download] Started: ${info.fileName}`));
+
+    let lastPercent = -1;
+    client.on('progress', (p) => {
+        // Show progress bar-like output
+        const percent = Math.floor(p.percent);
+        if (percent > lastPercent) {
+            const barWidth = 20;
+            const filled = Math.floor((percent / 100) * barWidth);
+            const empty = barWidth - filled;
+            const bar = '█'.repeat(filled) + '░'.repeat(empty);
+
+            process.stdout.write(`\r[Download] [${bar}] ${p.percent.toFixed(1)}% | ${p.speed} KB/s | ${p.bytesDownloaded} / ${p.totalBytes} bytes`);
+            lastPercent = percent;
+        }
+    });
+
+    client.on('connection-type', (c) => {
+        let typeStr = c.type;
+        if (c.type === CONNECTION_TYPE.DIRECT) typeStr += ' (P2P Direct)';
+        if (c.type === CONNECTION_TYPE.LOCAL) typeStr += ' (Local Network)';
+        if (c.type === CONNECTION_TYPE.RELAYED) typeStr += ' (Via Relay)';
+        console.log(`\n[Download] Connection established: ${typeStr}`);
+    });
+
+    client.on('error', (err) => console.error(`\n[Download] Error: ${err.message}`));
+
+    try {
+        // Use new simplified API
+        await client.get(magnetURI, outputPath);
+        console.log('\n\n==================================================');
+        console.log('       DOWNLOAD COMPLETE!');
+        console.log('==================================================');
+        console.log(`File saved to: ${outputPath}`);
+
+        // Show stats
+        const stats = client.lastDownloadStats;
+        console.log('Final Stats:');
+        console.log(`- Connection Type: ${stats.connectionType}`);
+        console.log(`- Remote Address: ${stats.remoteAddr}`);
+
+    } catch (err) {
+        console.error('\n[Download] Failed:', err);
+        process.exit(1);
+    }
+}
+
+download();

package/magnetk.js

@@ -1,18 +1,20 @@
 /**
  * Magnetk Link Parser and Generator for Magnetk P2P
+ * Supports DHT discovery and multi-relay configuration.
  */
 export class MagnetkLink {
-    constructor(fileHash, fileName, fileSize, seedId, relayAddr) {
+    constructor(fileHash, fileName, fileSize, seedId, relayAddr, dhtEnabled = false) {
         this.fileHash = fileHash;
         this.fileName = fileName;
         this.fileSize = fileSize;
         this.seedId = seedId;
         this.relayAddr = relayAddr;
+        this.dhtEnabled = dhtEnabled;
     }
 
     /**
      * Parses a magnetk URI string.
-     * Format: magnetk:?xt=urn:sha256:<hash>&dn=<name>&xl=<size>&xs=<seed_id>&relay=<relay_addr>
+     * Format: magnetk:?xt=urn:sha256:<hash>&dn=<name>&xl=<size>&xs=<seed_id>&relay=<relay_addr>&dht=true
      * @param {string} uri 
      * @returns {MagnetkLink}
      */
@@ -21,7 +23,7 @@ export class MagnetkLink {
             throw new Error('Invalid magnet link: must start with magnetk:?');
         }
 
-        const params = new URLSearchParams(uri.slice(9)); // slicing 'magnetk:?' length is 9? No. 'magnet:?' is 8. 'magnetk:?' is 9. Correct.
+        const params = new URLSearchParams(uri.slice(9));
         const xt = params.get('xt');
         if (!xt || !xt.startsWith('urn:sha256:')) {
             throw new Error('Invalid magnet link: missing xt (urn:sha256:...)');
@@ -32,8 +34,15 @@ export class MagnetkLink {
         const fileSize = parseInt(params.get('xl') || '0', 10);
         const seedId = params.get('xs') || '';
         const relayAddr = params.get('relay') || '';
+        const dhtParam = (params.get('dht') || '').toLowerCase();
+        const dhtEnabled = dhtParam === 'true' || dhtParam === '1';
 
-        return new MagnetkLink(fileHash, fileName, fileSize, seedId, relayAddr);
+        // Must have at least one discovery method
+        if (!relayAddr && !dhtEnabled) {
+            throw new Error('Magnet link needs either relay address or dht=true for discovery');
+        }
+
+        return new MagnetkLink(fileHash, fileName, fileSize, seedId, relayAddr, dhtEnabled);
     }
 
     /**
@@ -46,8 +55,15 @@ export class MagnetkLink {
         if (this.fileName) parts.push(`dn=${encodeURIComponent(this.fileName)}`);
         if (this.fileSize > 0) parts.push(`xl=${this.fileSize}`);
         if (this.seedId) parts.push(`xs=${encodeURIComponent(this.seedId)}`);
-        if (this.relayAddr) parts.push(`relay=${this.relayAddr}`); // Multiaddr usually kept raw
+        if (this.relayAddr) parts.push(`relay=${this.relayAddr}`);
+        if (this.dhtEnabled) parts.push('dht=true');
 
         return `magnetk:?${parts.join('&')}`;
     }
+
+    /** @returns {boolean} */
+    hasRelay() { return !!this.relayAddr; }
+
+    /** @returns {boolean} */
+    hasDHT() { return this.dhtEnabled; }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "magnetk",
-  "version": "2.2.4",
+  "version": "2.2.6",
   "description": "JavaScript SDK for Magnetk P2P File Transfer System",
   "main": "index.js",
   "bin": {

package/share.js

@@ -0,0 +1,62 @@
+import { MagnetkClient } from './client.js';
+import path from 'path';
+// import 'dotenv/config';
+
+const filePath = "./app.txt";
+
+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: 4002 // Data transfer port (must not conflict with relay 4003)
+    });
+
+    console.log(`[Share] Preparing to share: ${filePath}`);
+
+    // Check Public Identity
+    try {
+        console.log('[Share] Resolving Public Identity (STUN)...');
+        const identity = await client.getPublicIdentity();
+        console.log(`[Share] Public Identity: ${identity.ip}:${identity.port}`);
+    } catch (e) {
+        console.warn(`[Share] STUN lookup failed: ${e.message}`);
+    }
+
+    // Event listeners for feedback
+    client.on('validating-relay', () => console.log('[Share] Connecting to relay...'));
+    client.on('hashing', (p) => {
+        if (p.percent % 20 === 0 || p.percent === 100) {
+            console.log(`[Share] Hashing file... ${p.percent}%`);
+        }
+    });
+    client.on('relay-connected', (info) => console.log(`[Share] Connected to Relay at ${info.host}`));
+    client.on('seeding', (info) => {
+        console.log(`[Share] Seeding active: ${info.fileName} (${info.fileSize} bytes)`);
+        console.log(`[Share] File Hash: ${info.hash}`);
+    });
+    client.on('error', (err) => console.error(`[Share] Error: ${err.message}`));
+
+    try {
+        // Use new simplified API
+        const link = await client.share(filePath);
+
+        console.log('\n==================================================');
+        console.log('       FILE SHARED SUCCESSFULLY!');
+        console.log('==================================================');
+        console.log('\nmagnet link:');
+        console.log(link);
+        console.log('\nTo download, run:');
+        console.log(`node download.js "${link}"`);
+        console.log('\n[Share] Seeder running in background. Press Ctrl+C to stop.');
+
+        // Keep process alive
+        await client.keepSeeding();
+    } catch (err) {
+        console.error('[Share] Failed:', err);
+        client.stop();
+        process.exit(1);
+    }
+}
+
+share();