shogun-core 3.3.4 → 3.3.5

package/dist/ship/implementation/SHIP_06.js

@@ -1,350 +1,635 @@
 "use strict";
 /**
- * SHIP-06: Ephemeral P2P Messaging Implementation
+ * SHIP-06: Secure Vault 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
+ * Vault crittografato decentralizzato che dipende da SHIP-00 per l'identità.
  *
- * 2. With Identity: new SHIP_06(ISHIP_00, roomId) - Authenticated sessions
- *    - Uses existing Gun instance from SHIP-00
- *    - All ShogunCore features available
+ * Dipendenze:
+ * - SHIP-00 (Identity & Authentication) - per gestione utenti e chiavi
+ * - GunDB - per storage decentralizzato P2P
+ * - SEA - per crittografia AES-256-GCM
  *
- * 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
+ * Ispirato a: https://github.com/draeder/gunsafe
  */
 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!)
+// IMPLEMENTATION
 // ============================================================================
+/**
+ * SHIP-06 Reference Implementation
+ *
+ * Questa implementazione dipende da ISHIP_00 per tutte le operazioni di identità.
+ * Si concentra esclusivamente sulla logica del vault crittografato.
+ */
 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;
+    /**
+     * Constructor
+     * @param identity ISHIP_00 instance for identity operations
+     * @param vaultNodeName Optional custom vault node name
+     */
+    constructor(identity, vaultNodeName) {
+        this.initialized = false;
         // 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;
+        this.vaultNode = null;
+        this.recordsNode = null;
+        this.metadataNode = null;
+        if (!identity.isLoggedIn()) {
+            throw new Error("User must be authenticated via SHIP-00 before using SHIP-06");
         }
+        this.identity = identity;
+        this.vaultNodeName = vaultNodeName || SHIP_06.DEFAULT_NODE_NAME;
+        console.log("✅ SHIP-06 initialized");
     }
+    /**
+     * Get identity provider
+     */
     getIdentity() {
-        if (!this.identity) {
-            throw new Error("No identity - SHIP-06 running in standalone mode");
-        }
         return this.identity;
     }
-    async connect() {
-        if (this.connected)
+    // ========================================================================
+    // INITIALIZATION
+    // ========================================================================
+    /**
+     * Initialize vault
+     */
+    async initialize() {
+        if (this.initialized) {
+            console.warn("⚠️  Vault already initialized");
             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) {
+        }
+        try {
+            // Get Gun instance from 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("");
+            if (!shogun || !shogun.db) {
+                throw new Error("Cannot access ShogunCore from identity");
+            }
+            const gun = shogun.db.gun;
+            if (!gun) {
+                throw new Error("Cannot access GunDB");
+            }
+            // Get user node
+            const userNode = gun.user();
+            if (!userNode || !userNode.is) {
+                throw new Error("User not authenticated in Gun");
+            }
+            // Setup vault nodes
+            this.vaultNode = userNode.get(this.vaultNodeName);
+            this.recordsNode = this.vaultNode.get("records");
+            this.metadataNode = this.vaultNode.get("metadata");
+            // Initialize metadata
+            const existingMetadata = await this.metadataNode.then();
+            if (!existingMetadata || !existingMetadata.version) {
+                await this.metadataNode.put({
+                    version: SHIP_06.VAULT_VERSION,
+                    created: Date.now().toString(),
+                    recordCount: "0",
+                }).then();
+                console.log("📦 Vault metadata initialized");
             }
             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;
+                console.log("📦 Existing vault found");
             }
+            this.initialized = true;
+            console.log("✅ Vault initialized successfully");
         }
-        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);
+        catch (error) {
+            console.error("❌ Error initializing vault:", error);
+            throw error;
         }
-        this.connected = false;
     }
-    isConnected() {
-        return this.connected;
-    }
-    getSwarmId() {
-        return this.swarmId;
-    }
-    getAddress() {
-        return this.myAddress;
+    /**
+     * Check if vault is initialized
+     */
+    isInitialized() {
+        return this.initialized;
     }
     // ========================================================================
-    // PRESENCE
+    // CRUD OPERATIONS
     // ========================================================================
-    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(),
-                });
+    /**
+     * Store encrypted record in vault
+     */
+    async put(name, data, metadata) {
+        if (!this.initialized) {
+            return { success: false, error: "Vault not initialized" };
+        }
+        if (!name || name.trim() === "") {
+            return { success: false, error: "Record name cannot be empty" };
+        }
+        try {
+            // Get crypto and key pair
+            const shogun = this.identity.getShogun();
+            const crypto = shogun?.db?.crypto;
+            const pair = this.identity.getKeyPair();
+            if (!crypto || !pair) {
+                return { success: false, error: "Cannot access encryption" };
+            }
+            // Encrypt data
+            const dataString = JSON.stringify(data);
+            const encryptedData = await crypto.encrypt(dataString, pair.epriv);
+            // Encrypt metadata if provided
+            let encryptedMetadata;
+            if (metadata) {
+                const metadataString = JSON.stringify(metadata);
+                encryptedMetadata = await crypto.encrypt(metadataString, pair.epriv);
             }
-        }, 3000);
+            // Create encrypted record
+            const record = {
+                data: encryptedData,
+                created: Date.now().toString(),
+                updated: Date.now().toString(),
+                deleted: false,
+                metadata: encryptedMetadata,
+            };
+            // Store in vault
+            await this.recordsNode.get(name).put(record).then();
+            // Update vault metadata
+            await this.updateRecordCount();
+            console.log(`✅ Record stored: ${name}`);
+            return {
+                success: true,
+                recordName: name,
+            };
+        }
+        catch (error) {
+            console.error("❌ Error storing record:", error);
+            return {
+                success: false,
+                error: error.message,
+            };
+        }
     }
-    listenForPeers() {
-        if (this.config.debug) {
-            console.log(`👂 Listening for peers on: ephemeral/${this.swarmId.substring(0, 20)}...`);
+    /**
+     * Retrieve and decrypt record from vault
+     */
+    async get(name, options) {
+        if (!this.initialized) {
+            console.error("❌ Vault not initialized");
+            return null;
         }
-        this.presenceNode.map().on((data, address) => {
-            if (!data || !address || address === "_" || address === this.myAddress) {
-                return;
+        try {
+            // Retrieve encrypted record
+            const encryptedRecord = await this.recordsNode.get(name).then();
+            if (!encryptedRecord || !encryptedRecord.data) {
+                return null;
             }
-            if (!data.pub || !data.epub || !data.timestamp) {
-                return;
+            // Check if deleted (unless includeDeleted)
+            if (encryptedRecord.deleted && !options?.includeDeleted) {
+                return null;
             }
-            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));
+            // Get crypto and key pair
+            const shogun = this.identity.getShogun();
+            const crypto = shogun?.db?.crypto;
+            const pair = this.identity.getKeyPair();
+            if (!crypto || !pair) {
+                console.error("❌ Cannot access encryption");
+                return null;
+            }
+            // Decrypt data
+            const decryptedDataString = await crypto.decrypt(encryptedRecord.data, pair.epriv);
+            // Try to parse JSON, if it fails, use the string as-is
+            let decryptedData;
+            try {
+                decryptedData = JSON.parse(decryptedDataString);
+            }
+            catch (parseError) {
+                // If JSON.parse fails, the data is likely a plain string
+                // This can happen if the data was already a string value
+                decryptedData = decryptedDataString;
+            }
+            // Decrypt metadata if present
+            let decryptedMetadata;
+            if (encryptedRecord.metadata) {
+                try {
+                    const metadataString = await crypto.decrypt(encryptedRecord.metadata, pair.epriv);
+                    decryptedMetadata = JSON.parse(metadataString);
+                }
+                catch (error) {
+                    // Metadata decryption failed, continue without it
+                    console.warn("⚠️  Could not decrypt metadata");
                 }
             }
+            // Create vault record
+            const vaultRecord = {
+                name,
+                data: decryptedData,
+                created: parseInt(encryptedRecord.created),
+                updated: parseInt(encryptedRecord.updated),
+                deleted: encryptedRecord.deleted,
+                metadata: decryptedMetadata,
+            };
+            return vaultRecord;
+        }
+        catch (error) {
+            console.error("❌ Error retrieving record:", error);
+            return null;
+        }
+    }
+    /**
+     * Delete record from vault (soft delete)
+     */
+    async delete(name) {
+        if (!this.initialized) {
+            return { success: false, error: "Vault not initialized" };
+        }
+        try {
+            if (name) {
+                // Delete specific record (soft delete)
+                const existingRecord = await this.recordsNode.get(name).then();
+                if (!existingRecord) {
+                    return { success: false, error: `Record ${name} not found` };
+                }
+                // Mark as deleted
+                await this.recordsNode.get(name).get("deleted").put(true).then();
+                await this.recordsNode.get(name).get("updated").put(Date.now().toString()).then();
+                console.log(`🗑️  Record soft-deleted: ${name}`);
+                return {
+                    success: true,
+                    recordName: name,
+                };
+            }
             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;
+                // Delete all records (soft delete)
+                const allRecords = await this.list({ includeDeleted: false });
+                let deletedCount = 0;
+                for (const recordName of allRecords) {
+                    const result = await this.delete(recordName);
+                    if (result.success) {
+                        deletedCount++;
+                    }
                 }
+                console.log(`🗑️  ${deletedCount} records soft-deleted`);
+                return {
+                    success: true,
+                    recordCount: deletedCount,
+                };
             }
-        });
+        }
+        catch (error) {
+            console.error("❌ Error deleting record:", error);
+            return {
+                success: false,
+                error: error.message,
+            };
+        }
+    }
+    /**
+     * List all record names in vault
+     */
+    async list(options) {
+        if (!this.initialized) {
+            console.error("❌ Vault not initialized");
+            return [];
+        }
+        try {
+            return new Promise((resolve) => {
+                const recordNames = [];
+                this.recordsNode.map().once(async (record, key) => {
+                    // Skip metadata
+                    if (!record || typeof record !== "object" || key === "_") {
+                        return;
+                    }
+                    // Skip deleted records (unless includeDeleted)
+                    if (record.deleted && !options?.includeDeleted) {
+                        return;
+                    }
+                    // Apply filters if provided
+                    if (options?.filterByType || options?.filterByTag) {
+                        try {
+                            // Need to decrypt metadata to filter
+                            const shogun = this.identity.getShogun();
+                            const crypto = shogun?.db?.crypto;
+                            const pair = this.identity.getKeyPair();
+                            if (crypto && pair && record.metadata) {
+                                const metadataString = await crypto.decrypt(record.metadata, pair.epriv);
+                                const metadata = JSON.parse(metadataString);
+                                // Filter by type
+                                if (options.filterByType && metadata.type !== options.filterByType) {
+                                    return;
+                                }
+                                // Filter by tag
+                                if (options.filterByTag) {
+                                    if (!metadata.tags || !metadata.tags.includes(options.filterByTag)) {
+                                        return;
+                                    }
+                                }
+                            }
+                        }
+                        catch (error) {
+                            // Decryption failed, skip
+                            return;
+                        }
+                    }
+                    recordNames.push(key);
+                });
+                // Wait for Gun to return all records
+                setTimeout(() => {
+                    // Sort if requested
+                    if (options?.sortBy) {
+                        // For now, just sort by name
+                        recordNames.sort();
+                        if (options.sortDesc) {
+                            recordNames.reverse();
+                        }
+                    }
+                    resolve(recordNames);
+                }, 1000);
+            });
+        }
+        catch (error) {
+            console.error("❌ Error listing records:", error);
+            return [];
+        }
+    }
+    /**
+     * Check if record exists
+     */
+    async exists(name) {
+        const record = await this.get(name);
+        return record !== null;
+    }
+    /**
+     * Update existing record
+     */
+    async update(name, data) {
+        if (!this.initialized) {
+            return { success: false, error: "Vault not initialized" };
+        }
+        try {
+            // Check if record exists
+            const existingRecord = await this.get(name);
+            if (!existingRecord) {
+                return { success: false, error: `Record ${name} not found` };
+            }
+            // Keep existing metadata
+            return await this.put(name, data, existingRecord.metadata);
+        }
+        catch (error) {
+            console.error("❌ Error updating record:", error);
+            return {
+                success: false,
+                error: error.message,
+            };
+        }
     }
     // ========================================================================
-    // MESSAGING
+    // BACKUP & RESTORE
     // ========================================================================
-    async sendBroadcast(message) {
-        if (!this.connected || !this.myPair) {
-            throw new Error("Not connected");
-        }
-        if (this.peers.size === 0) {
-            console.warn("⚠️  No peers connected");
-            return;
+    /**
+     * Export entire vault (encrypted)
+     */
+    async export(password, options) {
+        if (!this.initialized) {
+            throw new Error("Vault not initialized");
         }
-        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",
+        try {
+            // Get all records
+            const recordNames = await this.list({
+                includeDeleted: options?.includeDeleted || false,
+                filterByTag: options?.filterByTag,
+                filterByType: options?.filterByType,
+            });
+            const records = {};
+            for (const name of recordNames) {
+                const record = await this.get(name, {
+                    includeDeleted: options?.includeDeleted || false,
                 });
+                if (record) {
+                    records[name] = record;
+                }
             }
-            catch (error) {
-                console.error(`   ❌ Error sending to ${address.substring(0, 8)}:`, error);
+            // Create export data
+            const exportData = {
+                version: SHIP_06.VAULT_VERSION,
+                exportedAt: Date.now(),
+                exportedBy: this.identity.getCurrentUser()?.pub,
+                recordCount: Object.keys(records).length,
+                records,
+            };
+            // Serialize to JSON
+            const jsonString = options?.pretty
+                ? JSON.stringify(exportData, null, 2)
+                : JSON.stringify(exportData);
+            // Optionally encrypt with password
+            if (password) {
+                const crypto = this.identity.shogun?.db?.crypto;
+                if (!crypto) {
+                    throw new Error("Cannot access crypto");
+                }
+                const encryptedJson = await crypto.encrypt(jsonString, password);
+                const base64 = Buffer.from(encryptedJson).toString("base64");
+                console.log(`✅ Vault exported (encrypted, ${base64.length} chars)`);
+                return base64;
             }
+            // Otherwise, return as base64
+            const base64 = Buffer.from(jsonString).toString("base64");
+            console.log(`✅ Vault exported (${base64.length} chars)`);
+            return base64;
+        }
+        catch (error) {
+            console.error("❌ Error exporting vault:", error);
+            throw 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);
+    /**
+     * Import vault from backup
+     */
+    async import(backupData, password, options) {
+        if (!this.initialized) {
+            return { success: false, error: "Vault not initialized" };
+        }
+        try {
+            // Decode base64
+            let jsonString = Buffer.from(backupData, "base64").toString("utf-8");
+            // Decrypt if password provided
+            if (password) {
+                const crypto = this.identity.shogun?.db?.crypto;
+                if (!crypto) {
+                    return { success: false, error: "Cannot access crypto" };
                 }
-                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));
+                jsonString = await crypto.decrypt(jsonString, password);
+            }
+            // Parse JSON
+            const importData = JSON.parse(jsonString);
+            // Validate version
+            if (importData.version !== SHIP_06.VAULT_VERSION) {
+                console.warn(`⚠️  Version mismatch: ${importData.version} vs ${SHIP_06.VAULT_VERSION}`);
             }
-            catch (error) {
-                if (this.config.debug) {
-                    console.error(`   ❌ Error:`, error);
+            // Import records
+            let importedCount = 0;
+            let skippedCount = 0;
+            for (const [name, record] of Object.entries(importData.records)) {
+                const vaultRecord = record;
+                // Skip deleted records if requested
+                if (options?.skipDeleted && vaultRecord.deleted) {
+                    skippedCount++;
+                    continue;
+                }
+                // Check if exists (if merge mode)
+                const exists = await this.exists(name);
+                if (exists) {
+                    if (options?.overwrite) {
+                        // Overwrite existing
+                        await this.put(name, vaultRecord.data, vaultRecord.metadata);
+                        importedCount++;
+                    }
+                    else if (!options?.merge) {
+                        // Skip if not merge and not overwrite
+                        skippedCount++;
+                        continue;
+                    }
+                    else {
+                        // Merge mode: skip existing
+                        skippedCount++;
+                        continue;
+                    }
+                }
+                else {
+                    // Import new record
+                    await this.put(name, vaultRecord.data, vaultRecord.metadata);
+                    importedCount++;
                 }
             }
-        });
+            console.log(`✅ Vault imported: ${importedCount} records (${skippedCount} skipped)`);
+            return {
+                success: true,
+                recordCount: importedCount,
+            };
+        }
+        catch (error) {
+            console.error("❌ Error importing vault:", error);
+            return {
+                success: false,
+                error: error.message,
+            };
+        }
     }
     // ========================================================================
-    // EVENT HANDLERS
+    // UTILITIES
     // ========================================================================
-    onMessage(callback) {
-        this.messageHandlers.push(callback);
-    }
-    onPeerSeen(callback) {
-        this.peerSeenHandlers.push(callback);
-    }
-    onPeerLeft(callback) {
-        this.peerLeftHandlers.push(callback);
-    }
-    onEncryptedMessage(callback) {
-        this.encryptedMessageHandlers.push(callback);
+    /**
+     * Get vault statistics
+     */
+    async getStats() {
+        if (!this.initialized) {
+            throw new Error("Vault not initialized");
+        }
+        try {
+            const allRecords = await this.list({ includeDeleted: true });
+            const activeRecords = await this.list({ includeDeleted: false });
+            // Get metadata
+            const metadata = await this.metadataNode.then();
+            const stats = {
+                totalRecords: allRecords.length,
+                activeRecords: activeRecords.length,
+                deletedRecords: allRecords.length - activeRecords.length,
+                totalSize: 0, // TODO: Calculate actual size
+                created: metadata?.created ? parseInt(metadata.created) : Date.now(),
+                lastModified: Date.now(),
+                recordsByType: {},
+            };
+            // Count by type
+            for (const name of activeRecords) {
+                const record = await this.get(name);
+                if (record && record.metadata?.type) {
+                    const type = record.metadata.type;
+                    stats.recordsByType[type] = (stats.recordsByType[type] || 0) + 1;
+                }
+            }
+            return stats;
+        }
+        catch (error) {
+            console.error("❌ Error getting stats:", error);
+            throw error;
+        }
     }
-    getPeers() {
-        return Array.from(this.peers.keys());
+    /**
+     * Clear all records (soft delete all)
+     */
+    async clear() {
+        return await this.delete(); // Delete without name = delete all
     }
-    getPeerInfo(address) {
-        return this.peers.get(address) || null;
+    /**
+     * Compact vault (remove deleted records permanently)
+     */
+    async compact() {
+        if (!this.initialized) {
+            return { success: false, error: "Vault not initialized" };
+        }
+        try {
+            // Get all deleted records
+            const allRecords = await this.list({ includeDeleted: true });
+            let compactedCount = 0;
+            for (const name of allRecords) {
+                const record = await this.get(name, { includeDeleted: true });
+                if (record && record.deleted) {
+                    // Permanently remove
+                    await this.recordsNode.get(name).put(null).then();
+                    compactedCount++;
+                }
+            }
+            // Update metadata
+            await this.updateRecordCount();
+            console.log(`✅ Vault compacted: ${compactedCount} records permanently removed`);
+            return {
+                success: true,
+                recordCount: compactedCount,
+            };
+        }
+        catch (error) {
+            console.error("❌ Error compacting vault:", error);
+            return {
+                success: false,
+                error: error.message,
+            };
+        }
     }
-    async getEphemeralPair() {
-        if (!this.myPair)
-            throw new Error("No ephemeral pair");
-        return this.myPair;
+    /**
+     * Search records by content
+     */
+    async search(query) {
+        if (!this.initialized) {
+            return [];
+        }
+        try {
+            const allRecords = await this.list({ includeDeleted: false });
+            const matches = [];
+            for (const name of allRecords) {
+                const record = await this.get(name);
+                if (record) {
+                    // Search in data (converted to string)
+                    const dataString = JSON.stringify(record.data).toLowerCase();
+                    const queryLower = query.toLowerCase();
+                    if (dataString.includes(queryLower) || name.toLowerCase().includes(queryLower)) {
+                        matches.push(name);
+                    }
+                }
+            }
+            return matches;
+        }
+        catch (error) {
+            console.error("❌ Error searching records:", error);
+            return [];
+        }
     }
-    async setEphemeralPair(pair) {
-        this.myPair = pair;
+    // ========================================================================
+    // PRIVATE HELPERS
+    // ========================================================================
+    /**
+     * Update record count in metadata
+     */
+    async updateRecordCount() {
+        try {
+            const activeRecords = await this.list({ includeDeleted: false });
+            await this.metadataNode.get("recordCount").put(activeRecords.length.toString()).then();
+        }
+        catch (error) {
+            console.error("❌ Error updating record count:", error);
+        }
     }
 }
 exports.SHIP_06 = SHIP_06;
+// Constants
+SHIP_06.VAULT_VERSION = "1.0.0";
+SHIP_06.DEFAULT_NODE_NAME = "vault";