shogun-core 3.3.0 → 3.3.2

package/dist/ship/implementation/SHIP_06.js

@@ -0,0 +1,350 @@
+"use strict";
+/**
+ * SHIP-06: Ephemeral P2P Messaging Implementation
+ *
+ * Two modes:
+ * 1. Standalone: new SHIP_06(gunPeers[], roomId) - NO authentication!
+ *    - Uses ShogunCore internally with silent: true, disableAutoRecall: true
+ *    - Zero logs, zero storage, pure relay communication
+ *    - Room hashed with Web Crypto API SHA-256 for deterministic IDs
+ *
+ * 2. With Identity: new SHIP_06(ISHIP_00, roomId) - Authenticated sessions
+ *    - Uses existing Gun instance from SHIP-00
+ *    - All ShogunCore features available
+ *
+ * Architecture:
+ * - Gun Relay for P2P communication (no WebRTC complexity!)
+ * - SEA for ephemeral key generation and ECDH encryption
+ * - Pure relay mode: radisk: false, localStorage: false, multicast: false
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SHIP_06 = void 0;
+const core_1 = require("../../src/core"); // ← Import diretto, NON da index!
+// ============================================================================
+// IMPLEMENTATION - STANDALONE VERSION (No ShogunCore dependency!)
+// ============================================================================
+class SHIP_06 {
+    // Constructor overload: with identity OR standalone
+    constructor(identityOrPeers, roomId, config) {
+        this.identity = null;
+        // State
+        this.connected = false;
+        this.swarmId = "";
+        this.myAddress = "";
+        this.myPair = null;
+        // Gun nodes
+        this.gun = null;
+        this.sea = null;
+        this.roomNode = null;
+        this.presenceNode = null;
+        this.messagesNode = null;
+        // Peers
+        this.peers = new Map();
+        // Event handlers
+        this.messageHandlers = [];
+        this.encryptedMessageHandlers = [];
+        this.peerSeenHandlers = [];
+        this.peerLeftHandlers = [];
+        // Heartbeat & cleanup
+        this.heartbeatInterval = null;
+        this.processedMessages = new Set();
+        this.roomId = roomId;
+        this.config = {
+            debug: config?.debug || false,
+            timeout: 30000,
+        };
+        if (Array.isArray(identityOrPeers)) {
+            // STANDALONE MODE - ShogunCore with silent mode
+            const shogunCore = new core_1.ShogunCore({
+                gunOptions: {
+                    peers: identityOrPeers,
+                    radisk: false,
+                    localStorage: false,
+                    multicast: false,
+                    axe: false,
+                },
+                silent: true,
+                disableAutoRecall: true,
+            });
+            this.gun = shogunCore.db.gun;
+            this.sea = shogunCore.db.sea;
+            this.identity = null;
+        }
+        else {
+            // WITH IDENTITY MODE - use existing Gun from SHIP-00
+            if (!identityOrPeers.isLoggedIn()) {
+                throw new Error("User must be authenticated via SHIP-00");
+            }
+            this.identity = identityOrPeers;
+            const shogun = identityOrPeers.getShogun();
+            this.gun = shogun.db.gun;
+        }
+    }
+    getIdentity() {
+        if (!this.identity) {
+            throw new Error("No identity - SHIP-06 running in standalone mode");
+        }
+        return this.identity;
+    }
+    async connect() {
+        if (this.connected)
+            return;
+        // Generate ephemeral pair
+        this.myPair = await this.sea.pair();
+        if (!this.myPair) {
+            throw new Error("Failed to generate SEA pair");
+        }
+        this.myAddress = this.myPair.pub.substring(0, 16);
+        // Hash room ID DETERMINISTICAMENTE - Simple SHA256 hash
+        if (this.identity) {
+            const shogun = this.identity.getShogun();
+            this.swarmId = await shogun.db.crypto.hashText(this.roomId);
+        }
+        else {
+            // Standalone: use simple deterministic hash
+            // SEA.work with different calls produces different results, so we use a simple hash
+            const encoder = new TextEncoder();
+            const data = encoder.encode(this.roomId);
+            // Use Web Crypto API for deterministic SHA-256 hash
+            if (typeof crypto !== "undefined" && crypto.subtle) {
+                const hashBuffer = await crypto.subtle.digest("SHA-256", data);
+                const hashArray = Array.from(new Uint8Array(hashBuffer));
+                this.swarmId = hashArray
+                    .map((b) => b.toString(16).padStart(2, "0"))
+                    .join("");
+            }
+            else {
+                // Fallback: simple deterministic hash
+                let hash = "";
+                for (let i = 0; i < this.roomId.length; i++) {
+                    hash += this.roomId.charCodeAt(i).toString(16);
+                }
+                this.swarmId = hash;
+            }
+        }
+        if (this.config.debug) {
+            console.log(`🔑 Room ID: "${this.roomId}"`);
+            console.log(`🔒 Swarm ID (hashed): ${this.swarmId.substring(0, 32)}...`);
+        }
+        // Setup Gun nodes
+        this.roomNode = this.gun.get("ephemeral").get(this.swarmId);
+        this.presenceNode = this.roomNode.get("presence");
+        this.messagesNode = this.roomNode.get("messages");
+        // Announce presence
+        await this.announcePresence();
+        // Start listening
+        this.listenForPeers();
+        this.listenForMessages();
+        // Start heartbeat
+        this.startHeartbeat();
+        this.connected = true;
+    }
+    disconnect() {
+        if (this.heartbeatInterval) {
+            clearInterval(this.heartbeatInterval);
+        }
+        if (this.presenceNode && this.myAddress) {
+            this.presenceNode.get(this.myAddress).put(null);
+        }
+        this.connected = false;
+    }
+    isConnected() {
+        return this.connected;
+    }
+    getSwarmId() {
+        return this.swarmId;
+    }
+    getAddress() {
+        return this.myAddress;
+    }
+    // ========================================================================
+    // PRESENCE
+    // ========================================================================
+    async announcePresence() {
+        if (!this.myPair)
+            return;
+        const presenceData = {
+            address: this.myAddress,
+            pub: this.myPair.pub,
+            epub: this.myPair.epub,
+            timestamp: Date.now(),
+        };
+        if (this.config.debug) {
+            console.log(`📡 Announcing presence: ${this.myAddress}`);
+        }
+        await this.presenceNode.get(this.myAddress).put(presenceData);
+    }
+    startHeartbeat() {
+        this.heartbeatInterval = setInterval(() => {
+            if (this.myPair) {
+                this.presenceNode.get(this.myAddress).put({
+                    address: this.myAddress,
+                    pub: this.myPair.pub,
+                    epub: this.myPair.epub,
+                    timestamp: Date.now(),
+                });
+            }
+        }, 3000);
+    }
+    listenForPeers() {
+        if (this.config.debug) {
+            console.log(`👂 Listening for peers on: ephemeral/${this.swarmId.substring(0, 20)}...`);
+        }
+        this.presenceNode.map().on((data, address) => {
+            if (!data || !address || address === "_" || address === this.myAddress) {
+                return;
+            }
+            if (!data.pub || !data.epub || !data.timestamp) {
+                return;
+            }
+            const age = Date.now() - (data.timestamp || 0);
+            const isOnline = age < 10000;
+            if (!this.peers.has(address)) {
+                this.peers.set(address, {
+                    address,
+                    pubKey: data.pub,
+                    epub: data.epub,
+                    pub: data.pub,
+                    connectedAt: data.timestamp,
+                });
+                if (isOnline) {
+                    this.peerSeenHandlers.forEach((h) => h(address));
+                }
+            }
+            else {
+                const peer = this.peers.get(address);
+                if (peer && data.timestamp > peer.connectedAt) {
+                    peer.connectedAt = data.timestamp;
+                    peer.pubKey = data.pub;
+                    peer.epub = data.epub;
+                    peer.pub = data.pub;
+                }
+            }
+        });
+    }
+    // ========================================================================
+    // MESSAGING
+    // ========================================================================
+    async sendBroadcast(message) {
+        if (!this.connected || !this.myPair) {
+            throw new Error("Not connected");
+        }
+        if (this.peers.size === 0) {
+            console.warn("⚠️  No peers connected");
+            return;
+        }
+        for (const [address, peer] of this.peers.entries()) {
+            try {
+                const secret = await this.sea.secret(peer.epub, this.myPair);
+                const encrypted = await this.sea.encrypt(message, secret);
+                const msgId = `${Date.now()}-${this.myAddress}-${Math.random().toString(36).substring(2, 9)}`;
+                await this.messagesNode.get(msgId).put({
+                    from: this.myAddress,
+                    fromPub: this.myPair.pub,
+                    fromEpub: this.myPair.epub,
+                    to: address,
+                    content: encrypted,
+                    timestamp: Date.now(),
+                    type: "broadcast",
+                });
+            }
+            catch (error) {
+                console.error(`   ❌ Error sending to ${address.substring(0, 8)}:`, error);
+            }
+        }
+    }
+    async sendDirect(peerAddress, message) {
+        const peer = this.peers.get(peerAddress);
+        if (!peer)
+            throw new Error(`Peer ${peerAddress} not found`);
+        if (!this.myPair)
+            throw new Error("No SEA pair");
+        const secret = await this.sea.secret(peer.epub, this.myPair);
+        const encrypted = await this.sea.encrypt(message, secret);
+        const msgId = `${Date.now()}-${this.myAddress}-${Math.random().toString(36).substring(2, 9)}`;
+        await this.messagesNode.get(msgId).put({
+            from: this.myAddress,
+            fromPub: this.myPair.pub,
+            fromEpub: this.myPair.epub,
+            to: peerAddress,
+            content: encrypted,
+            timestamp: Date.now(),
+            type: "direct",
+        });
+    }
+    listenForMessages() {
+        this.messagesNode.map().on(async (data, msgId) => {
+            if (!data || msgId === "_" || this.processedMessages.has(msgId))
+                return;
+            if (data.to !== this.myAddress || data.from === this.myAddress)
+                return;
+            this.processedMessages.add(msgId);
+            console.log(`\n📬 MESSAGE RECEIVED!`);
+            console.log(`   From: ${data.from.substring(0, 12)}...`);
+            try {
+                let peer = this.peers.get(data.from);
+                if (!peer && data.fromPub && data.fromEpub) {
+                    peer = {
+                        address: data.from,
+                        pubKey: data.fromPub,
+                        epub: data.fromEpub,
+                        pub: data.fromPub,
+                        connectedAt: data.timestamp,
+                    };
+                    this.peers.set(data.from, peer);
+                }
+                if (!peer || !this.myPair)
+                    return;
+                const senderEpub = data.fromEpub || peer.epub;
+                const secret = await this.sea.secret(senderEpub, this.myPair);
+                const decrypted = await this.sea.decrypt(data.content, secret);
+                if (!decrypted)
+                    return;
+                console.log(`   Content: "${decrypted}"`);
+                const ephemeralMsg = {
+                    from: data.from,
+                    fromPubKey: data.fromPub || peer.pubKey || "",
+                    content: decrypted,
+                    timestamp: data.timestamp,
+                    type: data.type,
+                };
+                this.messageHandlers.forEach((h) => h(ephemeralMsg));
+            }
+            catch (error) {
+                if (this.config.debug) {
+                    console.error(`   ❌ Error:`, error);
+                }
+            }
+        });
+    }
+    // ========================================================================
+    // EVENT HANDLERS
+    // ========================================================================
+    onMessage(callback) {
+        this.messageHandlers.push(callback);
+    }
+    onPeerSeen(callback) {
+        this.peerSeenHandlers.push(callback);
+    }
+    onPeerLeft(callback) {
+        this.peerLeftHandlers.push(callback);
+    }
+    onEncryptedMessage(callback) {
+        this.encryptedMessageHandlers.push(callback);
+    }
+    getPeers() {
+        return Array.from(this.peers.keys());
+    }
+    getPeerInfo(address) {
+        return this.peers.get(address) || null;
+    }
+    async getEphemeralPair() {
+        if (!this.myPair)
+            throw new Error("No ephemeral pair");
+        return this.myPair;
+    }
+    async setEphemeralPair(pair) {
+        this.myPair = pair;
+    }
+}
+exports.SHIP_06 = SHIP_06;