shogun-core 3.3.4 → 3.3.5

package/dist/ship/interfaces/ISHIP_06.js

@@ -1,59 +1,47 @@
 "use strict";
 /**
- * SHIP-06: Ephemeral P2P Messaging Interface
+ * SHIP-06: Secure Vault Interface
  *
- * @title ISHIP_06 - Ephemeral P2P Messaging
- * @notice Interface for ephemeral peer-to-peer messaging via Gun Relay
- * @dev Can work standalone OR with ISHIP_00 for authenticated sessions
+ * @title ISHIP_06 - Secure Encrypted Vault
+ * @notice Interface for secure encrypted key-value storage on GunDB
+ * @dev This interface depends on ISHIP_00 for identity and encryption
  *
  * ## Abstract
  *
- * This standard defines an interface for ephemeral P2P messaging that allows:
- * - Relay-based connections via Gun network
- * - End-to-end encrypted messages (no storage)
- * - Broadcast and direct messaging
- * - Deterministic room discovery (SHA-256)
- * - Standalone mode (no authentication needed!)
+ * This standard defines an interface for secure vault storage that allows:
+ * - End-to-end encrypted key-value storage
+ * - Soft delete with recovery
+ * - Export/import for backup
+ * - Rich metadata support
+ * - Simple, secure, focused on storage only
  *
  * ## Dependencies
  *
- * - Gun: Relay-based P2P database
- * - Gun SEA: Cryptography (ECDH + AES-GCM)
- * - ISHIP_00 (OPTIONAL): For authenticated sessions
- *
- * ## Modes
- *
- * **Standalone**: new SHIP_06(gunPeers[], roomId)
- * **With Identity**: new SHIP_06(ISHIP_00, roomId)
+ * - ISHIP_00: Identity and authentication layer
+ * - GunDB: P2P storage
+ * - SEA: Cryptography (AES-256-GCM)
  *
  * ## Inspiration
  *
- * Based on Bugoff (https://github.com/draeder/bugoff)
- * Simplified for Gun relay instead of WebRTC
+ * Based on Gunsafe (https://github.com/draeder/gunsafe)
+ * Adapted for Shogun ecosystem with SHIP-00 integration
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 // ============================================================================
 // IMPLEMENTATION EXAMPLE
 // ============================================================================
 /**
- * Example of how to implement ISHIP_06 with ISHIP_00 dependency
+ * Example of how to implement ISHIP_07 with ISHIP_00 dependency
  *
  * ```typescript
  * import { ISHIP_00 } from './ISHIP_00';
- * import { ISHIP_06, EphemeralMessage } from './ISHIP_06';
- * import Bugout from 'bugout';
- *
- * class EphemeralMessaging implements ISHIP_06 {
- *     private bugout: any;
- *     private ephemeralPair: SEAPair | null = null;
- *     private peers: Map<string, PeerInfo> = new Map();
- *     private messageCallbacks: ((msg: EphemeralMessage) => void)[] = [];
- *
- *     constructor(
- *         private identity: ISHIP_00,
- *         private roomId: string,
- *         private config?: EphemeralConfig
- *     ) {
+ * import { ISHIP_07, VaultRecord, VaultResult } from './ISHIP_07';
+ *
+ * class SecureVault implements ISHIP_07 {
+ *     private vaultNode: any;
+ *     private initialized: boolean = false;
+ *
+ *     constructor(private identity: ISHIP_00) {
  *         if (!identity.isLoggedIn()) {
  *             throw new Error('User must be authenticated via SHIP-00');
  *         }
@@ -63,82 +51,144 @@ Object.defineProperty(exports, "__esModule", { value: true });
  *         return this.identity;
  *     }
  *
- *     async connect(): Promise<void> {
- *         // 1. Generate ephemeral SEA pair
- *         const crypto = this.identity.shogun.db.crypto;
- *         this.ephemeralPair = await crypto.pair();
- *
- *         // 2. Hash room ID
- *         const swarmId = await crypto.hashText(this.roomId);
- *
- *         // 3. Create Bugout swarm
- *         this.bugout = new Bugout(swarmId, {
- *             iceServers: this.config?.iceServers
- *         });
- *
- *         // 4. Set SEA pair
- *         await this.bugout.SEA(this.ephemeralPair);
+ *     async initialize(): Promise<void> {
+ *         // Get Gun user node
+ *         const gun = this.identity.shogun.db.gun;
+ *         this.vaultNode = gun.user().get('vault').get('records');
  *
- *         // 5. Listen for events
- *         this.bugout.on('seen', (address: string) => {
- *             this.handlePeerSeen(address);
+ *         // Initialize vault metadata
+ *         await gun.user().get('vault').get('metadata').put({
+ *             version: '1.0.0',
+ *             created: Date.now().toString()
  *         });
  *
- *         this.bugout.on('decrypted', (address: string, pubkeys: any, message: string) => {
- *             this.handleMessage(address, pubkeys, message);
- *         });
+ *         this.initialized = true;
  *     }
  *
- *     disconnect(): void {
- *         if (this.bugout) {
- *             this.bugout.destroy();
- *         }
+ *     isInitialized(): boolean {
+ *         return this.initialized;
  *     }
  *
- *     async sendBroadcast(message: string): Promise<void> {
- *         if (!this.bugout) {
- *             throw new Error('Not connected to swarm');
+ *     async put(name: string, data: any, metadata?: RecordMetadata): Promise<VaultResult> {
+ *         if (!this.initialized) {
+ *             return { success: false, error: 'Vault not initialized' };
  *         }
  *
- *         this.bugout.send(message);
+ *         try {
+ *             // Get SEA crypto
+ *             const crypto = this.identity.shogun.db.crypto;
+ *             const pair = this.identity.getKeyPair();
+ *
+ *             if (!pair) {
+ *                 return { success: false, error: 'Cannot access key pair' };
+ *             }
+ *
+ *             // Encrypt data
+ *             const encryptedData = await crypto.encrypt(
+ *                 JSON.stringify(data),
+ *                 pair.epriv
+ *             );
+ *
+ *             // Encrypt metadata if provided
+ *             const encryptedMetadata = metadata
+ *                 ? await crypto.encrypt(JSON.stringify(metadata), pair.epriv)
+ *                 : undefined;
+ *
+ *             // Store in vault
+ *             const record = {
+ *                 data: encryptedData,
+ *                 created: Date.now().toString(),
+ *                 updated: Date.now().toString(),
+ *                 deleted: false,
+ *                 metadata: encryptedMetadata
+ *             };
+ *
+ *             await this.vaultNode.get(name).put(record);
+ *
+ *             return { success: true, recordName: name };
+ *         } catch (error: any) {
+ *             return { success: false, error: error.message };
+ *         }
  *     }
  *
- *     async sendDirect(peerAddress: string, message: string): Promise<void> {
- *         if (!this.bugout) {
- *             throw new Error('Not connected to swarm');
+ *     async get(name: string, options?: GetOptions): Promise<VaultRecord | null> {
+ *         if (!this.initialized) {
+ *             return null;
  *         }
  *
- *         this.bugout.send(peerAddress, message);
+ *         try {
+ *             // Retrieve from vault
+ *             const encryptedRecord = await this.vaultNode.get(name).then();
+ *
+ *             if (!encryptedRecord || !encryptedRecord.data) {
+ *                 return null;
+ *             }
+ *
+ *             // Skip if deleted (unless includeDeleted)
+ *             if (encryptedRecord.deleted && !options?.includeDeleted) {
+ *                 return null;
+ *             }
+ *
+ *             // Decrypt data
+ *             const crypto = this.identity.shogun.db.crypto;
+ *             const pair = this.identity.getKeyPair();
+ *
+ *             if (!pair) {
+ *                 return null;
+ *             }
+ *
+ *             const decryptedData = await crypto.decrypt(
+ *                 encryptedRecord.data,
+ *                 pair.epriv
+ *             );
+ *
+ *             // Decrypt metadata if present
+ *             const decryptedMetadata = encryptedRecord.metadata
+ *                 ? JSON.parse(await crypto.decrypt(encryptedRecord.metadata, pair.epriv))
+ *                 : undefined;
+ *
+ *             return {
+ *                 name,
+ *                 data: JSON.parse(decryptedData),
+ *                 created: parseInt(encryptedRecord.created),
+ *                 updated: parseInt(encryptedRecord.updated),
+ *                 deleted: encryptedRecord.deleted,
+ *                 metadata: decryptedMetadata
+ *             };
+ *         } catch (error) {
+ *             console.error('Error retrieving record:', error);
+ *             return null;
+ *         }
  *     }
  *
- *     onMessage(callback: (message: EphemeralMessage) => void): void {
- *         this.messageCallbacks.push(callback);
+ *     async delete(name?: string): Promise<VaultResult> {
+ *         // Implementation here
+ *         return { success: true };
  *     }
  *
- *     private handleMessage(address: string, pubkeys: any, content: string) {
- *         const message: EphemeralMessage = {
- *             from: address,
- *             fromPubKey: pubkeys.pub,
- *             content,
- *             timestamp: Date.now(),
- *             type: 'broadcast'
- *         };
- *
- *         this.messageCallbacks.forEach(cb => cb(message));
+ *     async list(options?: ListOptions): Promise<string[]> {
+ *         // Implementation here
+ *         return [];
  *     }
+ *
+ *     // ... implement other methods
  * }
  *
  * // Usage
  * const identity = new SHIP_00(config);
  * await identity.login('alice', 'password123');
  *
- * const ephemeral = new EphemeralMessaging(identity, 'my-room');
- * await ephemeral.connect();
+ * const vault = new SecureVault(identity);
+ * await vault.initialize();
  *
- * ephemeral.onMessage((msg) => {
- *     console.log(`${msg.from}: ${msg.content}`);
+ * // Store encrypted data
+ * await vault.put('my-password', 'super_secret', {
+ *     type: 'password',
+ *     description: 'GitHub password'
  * });
  *
- * await ephemeral.sendBroadcast('Hello everyone!');
+ * // Retrieve decrypted data
+ * const record = await vault.get('my-password');
+ * console.log('Password:', record?.data);
  * ```
  */

package/dist/src/gundb/db.js

@@ -113,9 +113,6 @@ class DataBase {
             this.user = this.gun.user().recall({ sessionStorage: true });
         }
         else {
-            if (!this.silent && !this.disableAutoRecall) {
-                console.log("No pair found in sessionStorage, using gun.user()");
-            }
             this.user = this.gun.user();
         }
         this.subscribeToAuthEvents();
@@ -164,7 +161,6 @@ class DataBase {
      */
     addPeer(peer) {
         this.gun.opt({ peers: [peer] });
-        console.log(`Added new peer: ${peer}`);
     }
     /**
      * Removes a peer from the network
@@ -182,10 +178,9 @@ class DataBase {
                 if (peerConnection && typeof peerConnection.close === "function") {
                     peerConnection.close();
                 }
-                console.log(`Removed peer: ${peer}`);
             }
             else {
-                console.log(`Peer not found in current connections: ${peer}`);
+                console.error(`Peer not found in current connections: ${peer}`);
             }
         }
         catch (error) {
@@ -270,7 +265,6 @@ class DataBase {
             this.removePeer(peer);
             // Add it back immediately instead of with timeout
             this.addPeer(peer);
-            console.log(`Reconnected to peer: ${peer}`);
         }
         catch (error) {
             console.error(`Error reconnecting to peer ${peer}:`, error);
@@ -294,7 +288,6 @@ class DataBase {
                         this.addPeer(peer);
                     });
                 }
-                console.log(`Gun database reset with ${newPeers ? newPeers.length : 0} peers: ${newPeers ? newPeers.join(", ") : "none"}`);
             }
         }
         catch (error) {
@@ -531,7 +524,6 @@ class DataBase {
                     else {
                         const recallResult = userInstance;
                     }
-                    // console.log("recallResult", recallResult);
                 }
                 catch (recallError) {
                     console.error("Error during recall:", recallError);
@@ -574,7 +566,6 @@ class DataBase {
         try {
             const currentUser = this.gun.user();
             if (!currentUser || !currentUser.is) {
-                console.log("No user logged in, skipping logout");
                 return;
             }
             // Log out user
@@ -733,7 +724,6 @@ class DataBase {
                         });
                     }
                     else {
-                        console.log(`User created successfully with userPub: ${userPub}`);
                         resolve({ success: true, userPub: userPub });
                     }
                 }
@@ -769,7 +759,6 @@ class DataBase {
             }
             if (pair) {
                 this.gun.user().auth(pair, (ack) => {
-                    console.log(`Pair authentication after creation result:`, ack);
                     if (ack.err) {
                         console.error(`Authentication after creation failed: ${ack.err}`);
                         resolve({ success: false, error: ack.err });
@@ -779,9 +768,6 @@ class DataBase {
                         setTimeout(() => {
                             // Extract userPub from multiple possible sources
                             const userPub = ack.pub || this.gun.user().is?.pub || ack.user?.pub;
-                            console.log(`Extracted userPub after pair auth: ${userPub}`);
-                            console.log(`User object after pair auth:`, this.gun.user());
-                            console.log(`User.is after pair auth:`, this.gun.user().is);
                             if (!userPub) {
                                 console.error("Authentication successful but no userPub found");
                                 resolve({
@@ -798,7 +784,6 @@ class DataBase {
             }
             else {
                 this.gun.user().auth(normalizedUsername, password, (ack) => {
-                    console.log(`Password authentication after creation result:`, ack);
                     if (ack.err) {
                         console.error(`Authentication after creation failed: ${ack.err}`);
                         resolve({ success: false, error: ack.err });
@@ -808,9 +793,6 @@ class DataBase {
                         setTimeout(() => {
                             // Extract userPub from multiple possible sources
                             const userPub = ack.pub || this.gun.user().is?.pub || ack.user?.pub;
-                            console.log(`Extracted userPub after password auth: ${userPub}`);
-                            console.log(`User object after password auth:`, this.gun.user());
-                            console.log(`User.is after password auth:`, this.gun.user().is);
                             if (!userPub) {
                                 console.error("Authentication successful but no userPub found");
                                 resolve({
@@ -874,7 +856,6 @@ class DataBase {
             this.user = this.gun.user();
             // Run post-authentication tasks
             try {
-                console.log(`Running post-auth setup with userPub: ${authResult.userPub}`);
                 const postAuthResult = await this.runPostAuthOnAuthResult(username, authResult.userPub, authResult);
                 // Return the post-auth result which includes the complete user data
                 return postAuthResult;
@@ -931,7 +912,6 @@ class DataBase {
             // For pair-based authentication, we don't need to call gun.user().create()
             // because the pair already contains the cryptographic credentials
             // We just need to validate that the pair is valid and return success
-            console.log(`User created successfully with pair for: ${normalizedUsername}`);
             resolve({ success: true, userPub: pair.pub });
         });
     }
@@ -964,7 +944,6 @@ class DataBase {
             if (normalizedUsername.length === 0) {
                 throw new Error("Username cannot be empty");
             }
-            console.log(`Setting up user profile for ${normalizedUsername} with userPub: ${userPub}`);
             const existingUser = await this.gun.get(userPub).then();
             const isNewUser = !existingUser || !existingUser.alias;
             // const isNewUser = true;
@@ -1042,7 +1021,6 @@ class DataBase {
             if (!userMetadataResult) {
                 return false;
             }
-            console.log(`Comprehensive user tracking setup completed for ${username}`);
             return true;
         }
         catch (error) {
@@ -1065,7 +1043,6 @@ class DataBase {
                 return false;
             }
             else {
-                console.log(`Alias index created: ~@${username} -> ${userPub}`);
                 return true;
             }
         }
@@ -1089,7 +1066,6 @@ class DataBase {
                 return false;
             }
             else {
-                console.log(`Username mapping created: ${username} -> ${userPub}`);
                 return true;
             }
         }
@@ -1120,7 +1096,6 @@ class DataBase {
                 return false;
             }
             else {
-                console.log(`User registry created: ${userPub}`);
                 return true;
             }
         }
@@ -1144,7 +1119,6 @@ class DataBase {
                 return false;
             }
             else {
-                console.log(`Reverse lookup created: ${userPub} -> ${username}`);
                 return true;
             }
         }
@@ -1164,7 +1138,6 @@ class DataBase {
                 return false;
             }
             else {
-                console.log(`Epub index created: ${epub} -> ${userPub}`);
                 return true;
             }
         }
@@ -1190,7 +1163,6 @@ class DataBase {
                 return false;
             }
             else {
-                console.log(`User metadata created for ${userPub}`);
                 return true;
             }
         }
@@ -1224,7 +1196,7 @@ class DataBase {
                 }
             }
             catch (error) {
-                console.log(`GunDB alias lookup failed for ${normalizedAlias}:`, error);
+                console.error(`GunDB alias lookup failed for ${normalizedAlias}:`, error);
             }
             // Method 2: Try username mapping (usernames/alias -> userPub)
             try {
@@ -1240,7 +1212,7 @@ class DataBase {
                 }
             }
             catch (error) {
-                console.log(`Username mapping lookup failed for ${normalizedAlias}:`, error);
+                console.error(`Username mapping lookup failed for ${normalizedAlias}:`, error);
             }
             return null;
         }
@@ -1273,7 +1245,7 @@ class DataBase {
                 }
             }
             catch (error) {
-                console.log(`User registry lookup failed for ${userPub}:`, error);
+                console.error(`User registry lookup failed for ${userPub}:`, error);
             }
             // Method 2: Try user's own node
             try {
@@ -1289,7 +1261,7 @@ class DataBase {
                 }
             }
             catch (error) {
-                console.log(`User node lookup failed for ${userPub}:`, error);
+                console.error(`User node lookup failed for ${userPub}:`, error);
             }
             return null;
         }
@@ -1373,14 +1345,14 @@ class DataBase {
                     .then();
             }
             catch (error) {
-                console.log(`Failed to update lastSeen in user registry:`, error);
+                console.error(`Failed to update lastSeen in user registry:`, error);
             }
             // Update in user's own node
             try {
                 await this.gun.get(userPub).get("lastSeen").put(timestamp).then();
             }
             catch (error) {
-                console.log(`Failed to update lastSeen in user node:`, error);
+                console.error(`Failed to update lastSeen in user node:`, error);
             }
         }
         catch (error) {
@@ -1392,10 +1364,8 @@ class DataBase {
      */
     async performAuthentication(username, password, pair) {
         return new Promise((resolve) => {
-            console.log(`Attempting authentication for user: ${username}`);
             if (pair) {
                 this.gun.user().auth(pair, (ack) => {
-                    console.log(`Pair authentication result:`, ack);
                     if (ack.err) {
                         console.error(`Login error for ${username}: ${ack.err}`);
                         resolve({ success: false, error: ack.err });
@@ -1407,7 +1377,6 @@ class DataBase {
             }
             else {
                 this.gun.user().auth(username, password, (ack) => {
-                    console.log(`Password authentication result:`, ack);
                     if (ack.err) {
                         console.error(`Login error for ${username}: ${ack.err}`);
                         resolve({ success: false, error: ack.err });
@@ -1456,9 +1425,6 @@ class DataBase {
             if (!alias) {
                 alias = username;
             }
-            console.log(`Login authentication successful, extracted userPub: ${userPub}`);
-            console.log(`User object:`, this.gun.user());
-            console.log(`User.is:`, this.gun.user().is);
             if (!userPub) {
                 return {
                     success: false,
@@ -1624,7 +1590,6 @@ class DataBase {
             if (!userPub) {
                 return { success: false, error: "User not found" };
             }
-            // console.log(`Found user public key for password recovery: ${userPub}`);
             // Access the user's security data directly from their public key node
             const securityData = await this.node.get(userPub)
                 .get("security")
@@ -1840,14 +1805,7 @@ exports.DataBase = DataBase;
 // Errors
 DataBase.Errors = GunErrors;
 const createGun = (config, silent) => {
-    if (!silent) {
-        console.log("Creating Gun instance with config:", config);
-        console.log("Config peers:", config?.peers);
-    }
     const gunInstance = (0, gun_1.default)(config);
-    if (!silent) {
-        console.log("Created Gun instance:", gunInstance);
-    }
     return gunInstance;
 };
 exports.createGun = createGun;