shogun-core 3.3.0 → 3.3.2

package/dist/ship/interfaces/ISHIP_04.js

@@ -0,0 +1,62 @@
+"use strict";
+/**
+ * SHIP-04: Multi-Modal Authentication Interface
+ *
+ * @title ISHIP_04 - Alternative Authentication Methods
+ * @notice Interface for multi-modal authentication extending SHIP-00
+ *
+ * ## Abstract
+ *
+ * This standard extends SHIP-00 to provide multiple authentication methods:
+ * - OAuth (Google, GitHub, Discord, etc.)
+ * - WebAuthn/Passkeys (biometric authentication)
+ * - Nostr (decentralized social protocol)
+ * - Web3 (MetaMask, WalletConnect, etc.)
+ *
+ * ## Dependencies
+ *
+ * - SHIP-00: Base identity foundation
+ * - Shogun Core Plugins: OAuth, WebAuthn, Nostr, Web3
+ *
+ * ## Inclusive Hierarchy
+ *
+ * SHIP-04 extends SHIP-00 (✅ allowed):
+ * ```
+ * SHIP-04 (Multi-Modal Auth)
+ *    ↓ depends on
+ * SHIP-00 (Identity Foundation)
+ * ```
+ *
+ * ## Usage
+ *
+ * ```typescript
+ * const identity = new SHIP_00(config);
+ * const multiAuth = new SHIP_04(identity);
+ *
+ * // Login with OAuth
+ * await multiAuth.loginWithOAuth('google');
+ *
+ * // Or WebAuthn
+ * await multiAuth.loginWithWebAuthn('alice');
+ *
+ * // Result is SHIP-00 compatible!
+ * const user = identity.getCurrentUser();
+ * ```
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuthMethod = void 0;
+// ============================================================================
+// CORE TYPES
+// ============================================================================
+/**
+ * Available authentication methods
+ * Exported as const enum to allow usage as both type and value
+ */
+var AuthMethod;
+(function (AuthMethod) {
+    AuthMethod["PASSWORD"] = "password";
+    AuthMethod["OAUTH"] = "oauth";
+    AuthMethod["WEBAUTHN"] = "webauthn";
+    AuthMethod["NOSTR"] = "nostr";
+    AuthMethod["WEB3"] = "web3";
+})(AuthMethod || (exports.AuthMethod = AuthMethod = {}));

package/dist/ship/interfaces/ISHIP_05.js

@@ -0,0 +1,59 @@
+"use strict";
+/**
+ * SHIP-05: Decentralized File Storage Interface
+ *
+ * @title ISHIP_05 - IPFS Storage with Relay Network
+ * @notice Interface for decentralized file storage with encryption
+ *
+ * ## Abstract
+ *
+ * This standard extends SHIP-00 to enable:
+ * - Encrypted file storage on IPFS
+ * - Relay network management for storage providers
+ * - On-chain subscription system for storage
+ * - Deterministic encryption from wallet signatures
+ * - File sharing with access control
+ *
+ * ## Specification
+ *
+ * Based on:
+ * - SHIP-00 for identity foundation
+ * - IPFS for decentralized storage
+ * - Smart contracts for relay payment system
+ * - Deterministic encryption from wallet signatures
+ *
+ * ## Dependencies
+ *
+ * - SHIP-00: Identity and authentication foundation
+ * - IPFS: Decentralized file storage
+ * - Ethereum: For relay subscription payments
+ * - shogun-ipfs: IPFS wrapper library
+ *
+ * ## Usage
+ *
+ * ```typescript
+ * const identity = new SHIP_00({ gunOptions: { peers: ['...'] } });
+ * await identity.login('alice', 'password123');
+ *
+ * const storage = new SHIP_05(identity);
+ * await storage.initialize();
+ *
+ * // Upload encrypted file
+ * const result = await storage.uploadFile(file, { encrypt: true });
+ *
+ * // Download and decrypt
+ * const data = await storage.downloadFile(result.hash, { decrypt: true });
+ * ```
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SHIP_05_EventType = void 0;
+// ============================================================================
+// EVENTS
+// ============================================================================
+var SHIP_05_EventType;
+(function (SHIP_05_EventType) {
+    SHIP_05_EventType["FILE_UPLOADED"] = "fileUploaded";
+    SHIP_05_EventType["FILE_DOWNLOADED"] = "fileDownloaded";
+    SHIP_05_EventType["FILE_DELETED"] = "fileDeleted";
+    SHIP_05_EventType["ERROR"] = "error";
+})(SHIP_05_EventType || (exports.SHIP_05_EventType = SHIP_05_EventType = {}));

package/dist/ship/interfaces/ISHIP_06.js

@@ -0,0 +1,144 @@
+"use strict";
+/**
+ * SHIP-06: Ephemeral P2P Messaging 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
+ *
+ * ## 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!)
+ *
+ * ## 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)
+ *
+ * ## Inspiration
+ *
+ * Based on Bugoff (https://github.com/draeder/bugoff)
+ * Simplified for Gun relay instead of WebRTC
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+// ============================================================================
+// IMPLEMENTATION EXAMPLE
+// ============================================================================
+/**
+ * Example of how to implement ISHIP_06 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
+ *     ) {
+ *         if (!identity.isLoggedIn()) {
+ *             throw new Error('User must be authenticated via SHIP-00');
+ *         }
+ *     }
+ *
+ *     getIdentity(): ISHIP_00 {
+ *         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);
+ *
+ *         // 5. Listen for events
+ *         this.bugout.on('seen', (address: string) => {
+ *             this.handlePeerSeen(address);
+ *         });
+ *
+ *         this.bugout.on('decrypted', (address: string, pubkeys: any, message: string) => {
+ *             this.handleMessage(address, pubkeys, message);
+ *         });
+ *     }
+ *
+ *     disconnect(): void {
+ *         if (this.bugout) {
+ *             this.bugout.destroy();
+ *         }
+ *     }
+ *
+ *     async sendBroadcast(message: string): Promise<void> {
+ *         if (!this.bugout) {
+ *             throw new Error('Not connected to swarm');
+ *         }
+ *
+ *         this.bugout.send(message);
+ *     }
+ *
+ *     async sendDirect(peerAddress: string, message: string): Promise<void> {
+ *         if (!this.bugout) {
+ *             throw new Error('Not connected to swarm');
+ *         }
+ *
+ *         this.bugout.send(peerAddress, message);
+ *     }
+ *
+ *     onMessage(callback: (message: EphemeralMessage) => void): void {
+ *         this.messageCallbacks.push(callback);
+ *     }
+ *
+ *     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));
+ *     }
+ * }
+ *
+ * // Usage
+ * const identity = new SHIP_00(config);
+ * await identity.login('alice', 'password123');
+ *
+ * const ephemeral = new EphemeralMessaging(identity, 'my-room');
+ * await ephemeral.connect();
+ *
+ * ephemeral.onMessage((msg) => {
+ *     console.log(`${msg.from}: ${msg.content}`);
+ * });
+ *
+ * await ephemeral.sendBroadcast('Hello everyone!');
+ * ```
+ */

package/dist/ship/interfaces/ISHIP_07.js

@@ -0,0 +1,194 @@
+"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/src/index.js

@@ -17,7 +17,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.autoQuickStart = exports.AutoQuickStart = exports.createSimpleAPI = exports.quickStart = exports.QuickStart = exports.SimpleGunAPI = exports.DataBase = exports.GunErrors = exports.derive = exports.crypto = exports.RxJS = exports.SEA = exports.ShogunCore = exports.Gun = exports.WalletCLI = exports.MessengerCLI = exports.SHIP_03 = exports.SHIP_02 = exports.SHIP_01 = exports.SHIP_00 = void 0;
+exports.autoQuickStart = exports.AutoQuickStart = exports.createSimpleAPI = exports.quickStart = exports.QuickStart = exports.SimpleGunAPI = exports.DataBase = exports.GunErrors = exports.derive = exports.crypto = exports.RxJS = exports.SEA = exports.ShogunCore = exports.Gun = void 0;
 const core_1 = require("./core");
 Object.defineProperty(exports, "ShogunCore", { enumerable: true, get: function () { return core_1.ShogunCore; } });
 const db_1 = require("./gundb/db");
@@ -42,17 +42,3 @@ __exportStar(require("./utils/errorHandler"), exports);
 __exportStar(require("./plugins"), exports);
 __exportStar(require("./interfaces/shogun"), exports);
 __exportStar(require("./config/simplified-config"), exports);
-var SHIP_00_1 = require("../ship/implementation/SHIP_00");
-Object.defineProperty(exports, "SHIP_00", { enumerable: true, get: function () { return SHIP_00_1.SHIP_00; } });
-var SHIP_01_1 = require("../ship/implementation/SHIP_01");
-Object.defineProperty(exports, "SHIP_01", { enumerable: true, get: function () { return SHIP_01_1.SHIP_01; } });
-var SHIP_02_1 = require("../ship/implementation/SHIP_02");
-Object.defineProperty(exports, "SHIP_02", { enumerable: true, get: function () { return SHIP_02_1.SHIP_02; } });
-var SHIP_03_1 = require("../ship/implementation/SHIP_03");
-Object.defineProperty(exports, "SHIP_03", { enumerable: true, get: function () { return SHIP_03_1.SHIP_03; } });
-// Export CLI tools only in Node.js environment (not browser)
-// This prevents "readline is not a function" errors in browser builds
-var messenger_cli_1 = require("../ship/examples/messenger-cli");
-Object.defineProperty(exports, "MessengerCLI", { enumerable: true, get: function () { return messenger_cli_1.MessengerCLI; } });
-var wallet_cli_1 = require("../ship/examples/wallet-cli");
-Object.defineProperty(exports, "WalletCLI", { enumerable: true, get: function () { return wallet_cli_1.WalletCLI; } });

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

@@ -0,0 +1,13 @@
+#!/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/examples/identity-cli.d.ts

@@ -0,0 +1,40 @@
+#!/usr/bin/env tsx
+/**
+ * SHIP-00 Identity CLI Example
+ *
+ * Interactive CLI demonstrating SHIP-00 identity and authentication
+ *
+ * Usage:
+ *   yarn identity <username> <password>
+ *
+ * Features:
+ * - User signup and login
+ * - Login with keypair (multi-device)
+ * - Public key publication
+ * - User discovery and lookup
+ * - Key pair export/import
+ * - Ethereum address derivation
+ */
+declare class IdentityCLI {
+    private identity;
+    private rl;
+    private username;
+    private running;
+    constructor();
+    login(username: string, password: string): Promise<boolean>;
+    loginWithKeypair(): Promise<void>;
+    exportKeypair(): Promise<void>;
+    showCurrentUser(): Promise<void>;
+    showPublicKey(): Promise<void>;
+    lookupUser(): Promise<void>;
+    lookupByPublicKey(): Promise<void>;
+    showMenu(): Promise<void>;
+    deriveAddress(): Promise<void>;
+    publishPublicKey(): Promise<void>;
+    logout(): Promise<void>;
+    private printHeader;
+    prompt(question: string): Promise<string>;
+    cleanup(): void;
+    start(username?: string, password?: string): Promise<void>;
+}
+export { IdentityCLI };

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

@@ -0,0 +1,31 @@
+#!/usr/bin/env tsx
+/**
+ * SHIP-03 Stealth Address CLI Example
+ *
+ * Demonstrates dual-key stealth addresses with Fluidkey integration
+ *
+ * Usage:
+ *   yarn stealth <username> <password>
+ */
+declare class StealthCLI {
+    private identity;
+    private eth;
+    private stealth;
+    private rl;
+    constructor();
+    login(username: string, password: string): Promise<boolean>;
+    register(username: string, password: string): Promise<boolean>;
+    showStealthKeys(): Promise<void>;
+    generateStealthAddress(): Promise<void>;
+    openStealthAddress(): Promise<void>;
+    batchGenerateStealthAddresses(): Promise<void>;
+    scanForStealthPayments(): Promise<void>;
+    showMenu(): Promise<void>;
+    lookupUserKeys(): Promise<void>;
+    exportKeys(): Promise<void>;
+    publishKeys(): Promise<void>;
+    showWalletInfo(): Promise<void>;
+    prompt(question: string): Promise<string>;
+    close(): void;
+}
+export { StealthCLI };

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

@@ -0,0 +1,48 @@
+#!/usr/bin/env tsx
+/**
+ * SHIP-05 Storage CLI Example
+ *
+ * Interactive CLI demonstrating SHIP-05 encrypted file storage on IPFS
+ *
+ * Usage:
+ *   yarn storage <username> <password>
+ *
+ * Features:
+ * - Encrypted file upload to IPFS (uses SEA from SHIP-00)
+ * - Multiple IPFS services (Pinata, IPFS Client, Custom Gateway)
+ * - File download and decryption
+ * - File metadata management
+ * - Storage statistics
+ */
+declare class StorageCLI {
+    private identity;
+    private storage;
+    private rl;
+    private username;
+    private running;
+    private ipfsService;
+    private ipfsConfig;
+    private configFile;
+    constructor();
+    login(username: string, password: string): Promise<boolean>;
+    configureIPFS(): Promise<void>;
+    configurePinata(): Promise<void>;
+    configureIPFSClient(): Promise<void>;
+    configureCustomGateway(): Promise<void>;
+    saveIPFSConfig(): void;
+    loadIPFSConfig(): boolean;
+    uploadFile(): Promise<void>;
+    downloadFile(): Promise<void>;
+    viewUserFiles(): Promise<void>;
+    deleteFile(): Promise<void>;
+    showStorageStats(): Promise<void>;
+    testEncryption(): Promise<void>;
+    showMenu(): Promise<void>;
+    reconfigureIPFS(): Promise<void>;
+    logout(): Promise<void>;
+    private printHeader;
+    prompt(question: string): Promise<string>;
+    cleanup(): void;
+    start(username?: string, password?: string): Promise<void>;
+}
+export { StorageCLI };

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

@@ -0,0 +1,13 @@
+#!/usr/bin/env tsx
+/**
+ * SHIP-07 Secure Vault CLI Example
+ *
+ * Test secure encrypted vault with SHIP-07
+ *
+ * Usage:
+ *   tsx ship/examples/vault-cli.ts <username> <password>
+ *
+ * Example:
+ *   tsx ship/examples/vault-cli.ts alice pass123
+ */
+export {};