shogun-core 3.3.4 → 3.3.5

package/dist/ship/interfaces/ISHIP_07.js

@@ -1,194 +0,0 @@
-"use strict";
-/**
- * SHIP-07: Secure Vault Interface
- *
- * @title ISHIP_07 - 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 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
- *
- * - ISHIP_00: Identity and authentication layer
- * - GunDB: P2P storage
- * - SEA: Cryptography (AES-256-GCM)
- *
- * ## Inspiration
- *
- * 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_07 with ISHIP_00 dependency
- *
- * ```typescript
- * import { ISHIP_00 } from './ISHIP_00';
- * 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');
- *         }
- *     }
- *
- *     getIdentity(): ISHIP_00 {
- *         return this.identity;
- *     }
- *
- *     async initialize(): Promise<void> {
- *         // Get Gun user node
- *         const gun = this.identity.shogun.db.gun;
- *         this.vaultNode = gun.user().get('vault').get('records');
- *
- *         // Initialize vault metadata
- *         await gun.user().get('vault').get('metadata').put({
- *             version: '1.0.0',
- *             created: Date.now().toString()
- *         });
- *
- *         this.initialized = true;
- *     }
- *
- *     isInitialized(): boolean {
- *         return this.initialized;
- *     }
- *
- *     async put(name: string, data: any, metadata?: RecordMetadata): Promise<VaultResult> {
- *         if (!this.initialized) {
- *             return { success: false, error: 'Vault not initialized' };
- *         }
- *
- *         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 get(name: string, options?: GetOptions): Promise<VaultRecord | null> {
- *         if (!this.initialized) {
- *             return null;
- *         }
- *
- *         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;
- *         }
- *     }
- *
- *     async delete(name?: string): Promise<VaultResult> {
- *         // Implementation here
- *         return { success: true };
- *     }
- *
- *     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 vault = new SecureVault(identity);
- * await vault.initialize();
- *
- * // Store encrypted data
- * await vault.put('my-password', 'super_secret', {
- *     type: 'password',
- *     description: 'GitHub password'
- * });
- *
- * // Retrieve decrypted data
- * const record = await vault.get('my-password');
- * console.log('Password:', record?.data);
- * ```
- */

package/dist/types/ship/examples/ephemeral-cli.d.ts

@@ -1,13 +0,0 @@
-#!/usr/bin/env tsx
-/**
- * SHIP-06 Ephemeral Chat - STANDALONE
- *
- * NO login/password required!
- *
- * Usage:
- *   tsx ship/examples/ephemeral-cli.ts <nickname> <room>
- *
- * Example:
- *   tsx ship/examples/ephemeral-cli.ts alice test-room
- */
-export {};

package/dist/types/ship/implementation/SHIP_07.d.ts

@@ -1,101 +0,0 @@
-/**
- * SHIP-07: Secure Vault Implementation
- *
- * Vault crittografato decentralizzato che dipende da SHIP-00 per l'identità.
- *
- * Dipendenze:
- * - SHIP-00 (Identity & Authentication) - per gestione utenti e chiavi
- * - GunDB - per storage decentralizzato P2P
- * - SEA - per crittografia AES-256-GCM
- *
- * Ispirato a: https://github.com/draeder/gunsafe
- */
-import type { ISHIP_00 } from "../interfaces/ISHIP_00";
-import type { ISHIP_07, VaultRecord, VaultResult, VaultStats, RecordMetadata, GetOptions, ListOptions, ImportOptions, ExportOptions } from "../interfaces/ISHIP_07";
-/**
- * SHIP-07 Reference Implementation
- *
- * Questa implementazione dipende da ISHIP_00 per tutte le operazioni di identità.
- * Si concentra esclusivamente sulla logica del vault crittografato.
- */
-declare class SHIP_07 implements ISHIP_07 {
-    private identity;
-    private initialized;
-    private vaultNodeName;
-    private vaultNode;
-    private recordsNode;
-    private metadataNode;
-    private static readonly VAULT_VERSION;
-    private static readonly DEFAULT_NODE_NAME;
-    /**
-     * Constructor
-     * @param identity ISHIP_00 instance for identity operations
-     * @param vaultNodeName Optional custom vault node name
-     */
-    constructor(identity: ISHIP_00, vaultNodeName?: string);
-    /**
-     * Get identity provider
-     */
-    getIdentity(): ISHIP_00;
-    /**
-     * Initialize vault
-     */
-    initialize(): Promise<void>;
-    /**
-     * Check if vault is initialized
-     */
-    isInitialized(): boolean;
-    /**
-     * Store encrypted record in vault
-     */
-    put(name: string, data: any, metadata?: RecordMetadata): Promise<VaultResult>;
-    /**
-     * Retrieve and decrypt record from vault
-     */
-    get(name: string, options?: GetOptions): Promise<VaultRecord | null>;
-    /**
-     * Delete record from vault (soft delete)
-     */
-    delete(name?: string): Promise<VaultResult>;
-    /**
-     * List all record names in vault
-     */
-    list(options?: ListOptions): Promise<string[]>;
-    /**
-     * Check if record exists
-     */
-    exists(name: string): Promise<boolean>;
-    /**
-     * Update existing record
-     */
-    update(name: string, data: any): Promise<VaultResult>;
-    /**
-     * Export entire vault (encrypted)
-     */
-    export(password?: string, options?: ExportOptions): Promise<string>;
-    /**
-     * Import vault from backup
-     */
-    import(backupData: string, password?: string, options?: ImportOptions): Promise<VaultResult>;
-    /**
-     * Get vault statistics
-     */
-    getStats(): Promise<VaultStats>;
-    /**
-     * Clear all records (soft delete all)
-     */
-    clear(): Promise<VaultResult>;
-    /**
-     * Compact vault (remove deleted records permanently)
-     */
-    compact(): Promise<VaultResult>;
-    /**
-     * Search records by content
-     */
-    search(query: string): Promise<string[]>;
-    /**
-     * Update record count in metadata
-     */
-    private updateRecordCount;
-}
-export { SHIP_07 };