shogun-core 5.2.1 → 5.3.0

package/dist/examples/auth-test.js

@@ -15,12 +15,17 @@ async function authTest() {
     // Use AutoQuickStart for easy setup with multiple peers for reliability
     const quickStart = new api_1.AutoQuickStart({
         peers: [
+            "https://lindanode.scobrudot.dev/gun",
+            "https://shogunnode.scobrudot.dev/gun",
             "https://peer.wallie.io/gun",
             "https://gun-manhattan.herokuapp.com/gun",
             "https://gun.defucc.me/gun",
+            "http://localhost:8765/gun",
         ],
-        appScope: "auth-test",
-        // Enable debug logging
+        wire: true,
+        axe: true,
+        radisk: false,
+        localStorage: false,
         enableGunDebug: true,
         enableConnectionMonitoring: true,
     });
@@ -34,47 +39,98 @@ async function authTest() {
     }
     const api = quickStart.api;
     const db = api.database;
+    console.log("peers:", db.gun._.opt.peers);
     console.log("- Database instance:", db ? "Available" : "Not available");
     console.log("- Current user:", db.getCurrentUser()?.alias || "None");
     console.log("- Is logged in:", db.isLoggedIn());
     console.log("");
     // === TEST 1: BASIC SIGNUP AND LOGIN ===
     console.log("🧪 === TEST 1: BASIC SIGNUP AND LOGIN ===\n");
-    const testUsername = `testuser_${Date.now()}`;
-    const testPassword = "testpass123!@#";
+    const testUsername = "scobru";
+    const testPassword = "francos88";
+    // Clean up any existing session
+    console.log("🧹 Cleaning up any existing session...");
+    db.logout();
+    await new Promise((resolve) => setTimeout(resolve, 1000)); // Wait 1 second
+    // Force reset auth state for problematic users
+    if (testUsername === "scobru") {
+        console.log("🔧 Performing aggressive cleanup for problematic user...");
+        db.aggressiveAuthCleanup();
+        await new Promise((resolve) => setTimeout(resolve, 3000)); // Wait 3 seconds
+        console.log("✓ Aggressive cleanup completed");
+    }
+    console.log("✓ Session cleanup completed\n");
     console.log(`Testing with username: ${testUsername}`);
     console.log(`Password: ${testPassword}\n`);
     // Test signup
     console.log("🔄 Attempting signup...");
     const signupStartTime = Date.now();
-    try {
-        const signupResult = await db.signUp(testUsername, testPassword);
-        const signupDuration = Date.now() - signupStartTime;
-        console.log(`✓ Signup completed in ${signupDuration}ms`);
-        console.log("Signup result:", {
-            success: signupResult.success,
-            userPub: signupResult.userPub
-                ? `${signupResult.userPub.substring(0, 20)}...`
-                : "None",
-            username: signupResult.username,
-            isNewUser: signupResult.isNewUser,
-            error: signupResult.error || "None",
+    // Check if user already exists before signup
+    console.log(`🔍 Pre-signup check for user: ${testUsername}`);
+    const preSignupCheck = await new Promise((resolve) => {
+        const timeout = setTimeout(() => {
+            console.log("⏰ Pre-signup check timeout");
+            resolve(false);
+        }, 3000);
+        db.gun.get(`~@${testUsername}`).once((data) => {
+            clearTimeout(timeout);
+            console.log("📊 Pre-signup data:", data ? "User exists" : "User not found");
+            if (data) {
+                console.log("🔑 User pub:", data.pub ? `${data.pub.substring(0, 20)}...` : "None");
+                console.log("📝 User keys:", Object.keys(data));
+            }
+            resolve(!!data && !!data.pub);
         });
-        if (!signupResult.success) {
-            console.error("❌ Signup failed:", signupResult.error);
-            return;
-        }
+    });
+    if (preSignupCheck) {
+        console.log("⚠️ User already exists, skipping signup and going directly to login");
     }
-    catch (error) {
-        console.error("❌ Signup threw exception:", error);
-        return;
+    else {
+        try {
+            // Add timeout for signup
+            const signupPromise = db.signUp(testUsername, testPassword);
+            const timeoutPromise = new Promise((_, reject) => setTimeout(() => reject(new Error("Signup timeout after 30 seconds")), 30000));
+            const signupResult = (await Promise.race([
+                signupPromise,
+                timeoutPromise,
+            ]));
+            const signupDuration = Date.now() - signupStartTime;
+            console.log(`✓ Signup completed in ${signupDuration}ms`);
+            console.log("Signup result:", {
+                success: signupResult.success,
+                userPub: signupResult.userPub
+                    ? `${signupResult.userPub.substring(0, 20)}...`
+                    : "None",
+                username: signupResult.username,
+                isNewUser: signupResult.isNewUser,
+                error: signupResult.error || "None",
+            });
+            if (!signupResult.success) {
+                console.log("ℹ️ Signup failed, user might already exist. Will try login...");
+            }
+        }
+        catch (error) {
+            console.log("ℹ️ Signup threw exception, user might already exist. Will try login...");
+            console.log("Exception details:", error);
+        }
     }
+    // Wait a moment before attempting login
+    console.log("⏳ Waiting 2 seconds before login attempt...");
+    await new Promise((resolve) => setTimeout(resolve, 2000));
     console.log("");
     // Test login
     console.log("🔄 Attempting login...");
     const loginStartTime = Date.now();
     try {
-        const loginResult = await db.login(testUsername, testPassword);
+        // Skip user existence check and try direct login
+        console.log("🔄 Attempting direct login (bypassing user existence check)...");
+        // Add timeout for login
+        const loginPromise = db.login(testUsername, testPassword);
+        const timeoutPromise = new Promise((_, reject) => setTimeout(() => reject(new Error("Login timeout after 30 seconds")), 30000));
+        const loginResult = (await Promise.race([
+            loginPromise,
+            timeoutPromise,
+        ]));
         const loginDuration = Date.now() - loginStartTime;
         console.log(`✓ Login completed in ${loginDuration}ms`);
         console.log("Login result:", {
@@ -87,6 +143,7 @@ async function authTest() {
         });
         if (!loginResult.success) {
             console.error("❌ Login failed:", loginResult.error);
+            console.log("ℹ️ If this is a new user, try running the test again after a few seconds");
             return;
         }
         // Verify user state

package/dist/examples/crypto-identity-example.js

@@ -12,15 +12,20 @@ async function cryptoIdentityExample() {
     // 1. Inizializza ShogunCore
     const core = new index_1.ShogunCore({
         gunOptions: {
-            peers: ["https://peer.wallie.io/gun"],
-            radisk: true,
+            peers: [
+                "https://peer.wallie.io/gun",
+                "https://shogunnode.scobrudot.dev/gun",
+                "https://shogunnode2.scobrudot.dev/gun",
+                "https://lindanode.scobrudot.dev/gun",
+            ],
+            radisk: false,
             localStorage: false,
         },
     });
     console.log("✅ ShogunCore inizializzato");
     // 2. Registra un nuovo utente (genera automaticamente SEA pair)
-    const username = `mario_rossi_${Date.now()}`;
-    const signupResult = await core.signUp(username, "password123");
+    const username = `scobru`;
+    const signupResult = await core.signUp(username, "francos88");
     if (!signupResult.success) {
         console.error("❌ Registrazione fallita:", signupResult.error);
         return;
@@ -52,7 +57,7 @@ async function cryptoIdentityExample() {
     }
     // 5. Esempio di login con utente esistente
     console.log("\n🔄 Test login con utente esistente...");
-    const loginResult = await core.login(username, "password123");
+    const loginResult = await core.login(username, "francos88");
     if (loginResult.success) {
         console.log("✅ Login riuscito");
         // Le identità crypto esistenti vengono recuperate automaticamente
@@ -82,8 +87,13 @@ async function multiAuthExample() {
     console.log("\n🔐 Esempio con diversi metodi di autenticazione");
     const core = new index_1.ShogunCore({
         gunOptions: {
-            peers: ["https://peer.wallie.io/gun"],
-            radisk: true,
+            peers: [
+                "https://peer.wallie.io/gun",
+                "https://shogunnode.scobrudot.dev/gun",
+                "https://shogunnode2.scobrudot.dev/gun",
+                "https://lindanode.scobrudot.dev/gun",
+            ],
+            radisk: false,
             localStorage: false,
         },
     });

package/dist/gundb/db.js

@@ -129,7 +129,7 @@ class DataBase {
             this.node = this.gun.get(appScope);
             console.log("[DB] App scope node initialized");
             // Initialize CryptoIdentityManager
-            this._cryptoIdentityManager = new CryptoIdentityManager_1.CryptoIdentityManager(this.core);
+            this._cryptoIdentityManager = new CryptoIdentityManager_1.CryptoIdentityManager(this.core, this);
             console.log("[DB] CryptoIdentityManager initialized");
             if (sessionResult.success) {
                 console.log("[DB] Session automatically restored");
@@ -577,6 +577,10 @@ class DataBase {
             // Log out user
             try {
                 currentUser.leave();
+                // Force clear any pending authentication
+                if (currentUser._ && currentUser._.sea) {
+                    currentUser._.sea = null;
+                }
             }
             catch (gunError) {
                 console.error("Error during Gun logout:", gunError);
@@ -715,6 +719,8 @@ class DataBase {
             this.gun.user().create(normalizedUsername, password, (ack) => {
                 if (ack.err) {
                     console.error(`User creation error: ${ack.err}`);
+                    // Reset auth state after failed creation to prevent blocking future operations
+                    this.resetAuthState();
                     resolve({ success: false, error: ack.err });
                 }
                 else {
@@ -767,6 +773,8 @@ class DataBase {
                 this.gun.user().auth(pair, (ack) => {
                     if (ack.err) {
                         console.error(`Authentication after creation failed: ${ack.err}`);
+                        // Reset auth state on error to prevent blocking future operations
+                        this.resetAuthState();
                         resolve({ success: false, error: ack.err });
                     }
                     else {
@@ -792,6 +800,8 @@ class DataBase {
                 this.gun.user().auth(normalizedUsername, password, (ack) => {
                     if (ack.err) {
                         console.error(`Authentication after creation failed: ${ack.err}`);
+                        // Reset auth state on error to prevent blocking future operations
+                        this.resetAuthState();
                         resolve({ success: false, error: ack.err });
                     }
                     else {
@@ -822,13 +832,33 @@ class DataBase {
      * @param pair Optional SEA pair for Web3 login
      * @returns Promise resolving to signup result
      */
-    async signUp(username, password, pair) {
+    async signUp(username, password, pair, retryCount = 0, maxRetries = 3) {
         try {
             // Validate credentials with enhanced security
             const validation = this.validateSignupCredentials(username, password, pair);
             if (!validation.valid) {
                 return { success: false, error: validation.error };
             }
+            // Check if authentication is in progress and retry if needed
+            if (this.isAuthInProgress()) {
+                if (retryCount < maxRetries) {
+                    console.warn(`Authentication in progress during signup, retrying... (${retryCount + 1}/${maxRetries})`);
+                    this.resetAuthState();
+                    const baseDelay = 100 * Math.pow(2, retryCount);
+                    const jitter = Math.random() * 100;
+                    const delay = Math.min(baseDelay + jitter, 2000);
+                    await new Promise((resolve) => setTimeout(resolve, delay));
+                    return this.signUp(username, password, pair, retryCount + 1, maxRetries);
+                }
+                else {
+                    console.error("Max retries exceeded for signup due to concurrent operations");
+                    this.resetAuthState();
+                    return {
+                        success: false,
+                        error: "Signup failed after multiple retries due to concurrent operations",
+                    };
+                }
+            }
             let createResult;
             if (pair) {
                 // For Web3/plugin authentication, use pair-based creation
@@ -839,6 +869,8 @@ class DataBase {
                 createResult = await this.createNewUser(username, password);
             }
             if (!createResult.success) {
+                // Reset auth state after failed creation to prevent blocking future operations
+                this.resetAuthState();
                 return { success: false, error: createResult.error };
             }
             // Add a small delay to ensure user is properly registered
@@ -1453,33 +1485,134 @@ class DataBase {
         }
     }
     /**
-     * Performs authentication with Gun
+     * Resets Gun.js authentication state to allow new auth operations
+     */
+    resetAuthState() {
+        try {
+            const currentUser = this.gun.user();
+            if (currentUser && currentUser._) {
+                // Reset the authentication flag
+                if (currentUser._.sea) {
+                    currentUser._.sea = null;
+                }
+                // Reset the ing flag that prevents concurrent operations
+                if (currentUser._.ing) {
+                    currentUser._.ing = false;
+                }
+                // Force clear any pending authentication callbacks
+                if (currentUser._.auth) {
+                    currentUser._.auth = null;
+                }
+                // Clear any pending operations
+                if (currentUser._.act) {
+                    currentUser._.act = null;
+                }
+                // Clear any pending callbacks
+                if (currentUser._.cb) {
+                    currentUser._.cb = null;
+                }
+                // Clear any pending retries
+                if (currentUser._.retries) {
+                    currentUser._.retries = 0;
+                }
+                // Clear any pending timeouts
+                if (currentUser._.timeout) {
+                    clearTimeout(currentUser._.timeout);
+                    currentUser._.timeout = null;
+                }
+            }
+            // Also try to call leave() to ensure clean state
+            try {
+                currentUser.leave();
+            }
+            catch (leaveError) {
+                // Ignore leave errors, just trying to clean up
+            }
+            // Force clear the user reference to ensure clean state
+            this.user = null;
+            console.log("Auth state reset completed");
+        }
+        catch (error) {
+            console.warn("Error resetting auth state:", error);
+        }
+    }
+    /**
+     * Performs authentication with Gun with retry mechanism
      */
-    async performAuthentication(username, password, pair) {
+    async performAuthentication(username, password, pair, retryCount = 0, maxRetries = 3) {
         return new Promise((resolve) => {
-            if (pair) {
-                this.gun.user().auth(pair, (ack) => {
-                    if (ack.err) {
-                        console.error(`Login error for ${username}: ${ack.err}`);
-                        resolve({ success: false, error: ack.err });
-                    }
-                    else {
-                        resolve({ success: true, ack });
+            // Check if there's already an authentication operation in progress
+            const currentUser = this.gun.user();
+            if (currentUser && currentUser._ && currentUser._.ing) {
+                if (retryCount < maxRetries) {
+                    console.warn(`Authentication already in progress, retrying... (${retryCount + 1}/${maxRetries})`);
+                    this.resetAuthState();
+                    // For the first retry, try to create a fresh authentication context
+                    if (retryCount === 0) {
+                        this.createFreshAuthContext();
                     }
+                    // Add exponential backoff delay with jitter
+                    const baseDelay = 200 * Math.pow(2, retryCount);
+                    const jitter = Math.random() * 200;
+                    const delay = Math.min(baseDelay + jitter, 3000);
+                    setTimeout(() => {
+                        this.performAuthentication(username, password, pair, retryCount + 1, maxRetries)
+                            .then(resolve)
+                            .catch((error) => resolve({ success: false, error: String(error) }));
+                    }, delay);
+                    return;
+                }
+                else {
+                    console.error("Max retries exceeded for authentication");
+                    this.resetAuthState();
+                    resolve({
+                        success: false,
+                        error: "Authentication failed after multiple retries",
+                    });
+                    return;
+                }
+            }
+            this.performAuthenticationInternal(username, password, pair, resolve);
+        });
+    }
+    /**
+     * Internal authentication method with timeout
+     */
+    performAuthenticationInternal(username, password, pair, resolve) {
+        let resolved = false;
+        const timeout = 15000; // 15 second timeout for individual auth attempts
+        const timeoutId = setTimeout(() => {
+            if (!resolved) {
+                resolved = true;
+                console.error(`Authentication timeout for ${username} after ${timeout}ms`);
+                this.resetAuthState();
+                resolve({
+                    success: false,
+                    error: `Authentication timeout after ${timeout}ms`,
                 });
             }
+        }, timeout);
+        const authCallback = (ack) => {
+            if (resolved)
+                return;
+            resolved = true;
+            clearTimeout(timeoutId);
+            if (ack.err) {
+                console.error(`Login error for ${username}: ${ack.err}`);
+                // Reset auth state on error to prevent blocking future attempts
+                this.resetAuthState();
+                resolve({ success: false, error: ack.err });
+            }
             else {
-                this.gun.user().auth(username, password, (ack) => {
-                    if (ack.err) {
-                        console.error(`Login error for ${username}: ${ack.err}`);
-                        resolve({ success: false, error: ack.err });
-                    }
-                    else {
-                        resolve({ success: true, ack });
-                    }
-                });
+                resolve({ success: true, ack });
             }
-        });
+        };
+        if (pair) {
+            this.gun.user().auth(pair, authCallback);
+        }
+        else {
+            this.gun.user().auth(username, password, authCallback);
+        }
     }
     /**
      * Builds login result object
@@ -1513,9 +1646,28 @@ class DataBase {
         try {
             const loginResult = await this.performAuthentication(username, password, pair);
             if (!loginResult.success) {
+                // Provide more specific error messages based on the error type
+                let errorMessage = `User '${username}' not found. Please check your username or register first.`;
+                if (loginResult.error) {
+                    if (loginResult.error.includes("already being created or authenticated")) {
+                        errorMessage =
+                            "Authentication is already in progress. Please wait and try again.";
+                    }
+                    else if (loginResult.error.includes("Wrong user or password")) {
+                        errorMessage =
+                            "Invalid username or password. Please check your credentials.";
+                    }
+                    else if (loginResult.error.includes("User already created")) {
+                        errorMessage =
+                            "User already exists. Please try logging in instead.";
+                    }
+                    else {
+                        errorMessage = loginResult.error;
+                    }
+                }
                 return {
                     success: false,
-                    error: `User '${username}' not found. Please check your username or register first.`,
+                    error: errorMessage,
                 };
             }
             // Add a small delay to ensure user state is properly set
@@ -1934,6 +2086,128 @@ class DataBase {
     isAuthenticated() {
         return this.user?.is?.pub ? true : false;
     }
+    /**
+     * Check if an authentication operation is currently in progress
+     */
+    isAuthInProgress() {
+        try {
+            const currentUser = this.gun.user();
+            return !!(currentUser && currentUser._ && currentUser._.ing);
+        }
+        catch (error) {
+            console.warn("Error checking auth progress:", error);
+            return false;
+        }
+    }
+    /**
+     * Force reset authentication state (useful for debugging or recovery)
+     */
+    forceResetAuthState() {
+        this.resetAuthState();
+    }
+    /**
+     * Aggressive cleanup for problematic users
+     * This method performs a complete reset of all authentication state
+     */
+    aggressiveAuthCleanup() {
+        try {
+            console.log("🧹 Performing aggressive auth cleanup...");
+            // Reset all auth state
+            this.resetAuthState();
+            // Clear all Gun.js internal state
+            const currentUser = this.gun.user();
+            if (currentUser && currentUser._) {
+                // Clear all possible internal flags
+                const internalState = currentUser._;
+                Object.keys(internalState).forEach((key) => {
+                    if (typeof internalState[key] === "boolean") {
+                        internalState[key] = false;
+                    }
+                    else if (typeof internalState[key] === "object" &&
+                        internalState[key] !== null) {
+                        if (key === "sea" ||
+                            key === "auth" ||
+                            key === "act" ||
+                            key === "cb") {
+                            internalState[key] = null;
+                        }
+                    }
+                });
+            }
+            // Force logout
+            try {
+                currentUser.leave();
+            }
+            catch (error) {
+                // Ignore errors
+            }
+            // Clear user reference
+            this.user = null;
+            // Clear all session storage
+            if (typeof sessionStorage !== "undefined") {
+                try {
+                    const keys = Object.keys(sessionStorage);
+                    keys.forEach((key) => {
+                        if (key.includes("gun") ||
+                            key.includes("user") ||
+                            key.includes("auth")) {
+                            sessionStorage.removeItem(key);
+                        }
+                    });
+                }
+                catch (error) {
+                    // Ignore errors
+                }
+            }
+            // Clear all local storage
+            if (typeof localStorage !== "undefined") {
+                try {
+                    const keys = Object.keys(localStorage);
+                    keys.forEach((key) => {
+                        if (key.includes("gun") ||
+                            key.includes("user") ||
+                            key.includes("auth")) {
+                            localStorage.removeItem(key);
+                        }
+                    });
+                }
+                catch (error) {
+                    // Ignore errors
+                }
+            }
+            console.log("✓ Aggressive auth cleanup completed");
+        }
+        catch (error) {
+            console.error("Error during aggressive cleanup:", error);
+        }
+    }
+    /**
+     * Creates a completely fresh authentication context
+     * This is a more aggressive approach when normal reset doesn't work
+     */
+    createFreshAuthContext() {
+        try {
+            // Reset all auth state
+            this.resetAuthState();
+            // Create a completely new user instance
+            const freshUser = this.gun.user();
+            this.user = freshUser;
+            // Clear any cached authentication data
+            if (typeof sessionStorage !== "undefined") {
+                try {
+                    sessionStorage.removeItem("gunSessionData");
+                    sessionStorage.removeItem("gunUserData");
+                }
+                catch (error) {
+                    console.warn("Error clearing session storage:", error);
+                }
+            }
+            console.log("Fresh authentication context created");
+        }
+        catch (error) {
+            console.error("Error creating fresh auth context:", error);
+        }
+    }
 }
 exports.DataBase = DataBase;
 // Errors

package/dist/managers/CryptoIdentityManager.js

@@ -21,8 +21,9 @@ const errorHandler_1 = require("../utils/errorHandler");
  * Genera automaticamente tutte le identità crypto disponibili dopo l'autenticazione SEA
  */
 class CryptoIdentityManager {
-    constructor(core) {
+    constructor(core, db) {
         this.core = core;
+        this.db = db;
         this.pgpManager = new pgp_1.PGPManager();
         this.mlsManager = new mls_1.MLSManager("default-user");
         this.sframeManager = new sframe_1.SFrameManager();
@@ -144,7 +145,7 @@ class CryptoIdentityManager {
             }
             // Salva su GunDB nel percorso privato dell'utente
             const saveResult = await new Promise((resolve, reject) => {
-                this.core.gun
+                this.db.gun
                     .user()
                     .get("crypto-identities")
                     .put(encryptedIdentities, (ack) => {
@@ -164,7 +165,7 @@ class CryptoIdentityManager {
                 name: "SHA-256",
             });
             await new Promise((resolve, reject) => {
-                this.core.gun
+                this.db.gun
                     .user()
                     .get("crypto-identities-hash")
                     .put(identitiesHash, (ack) => {
@@ -205,7 +206,7 @@ class CryptoIdentityManager {
             console.log(`🔍 [CryptoIdentityManager] Retrieving crypto identities for: ${username}`);
             // Recupera le identità criptate da GunDB
             const encryptedIdentities = await new Promise((resolve, reject) => {
-                this.core.gun
+                this.db.gun
                     .user()
                     .get("crypto-identities")
                     .once((data) => {
@@ -257,7 +258,7 @@ class CryptoIdentityManager {
     async hasStoredIdentities(username) {
         try {
             const hasIdentities = await new Promise((resolve) => {
-                this.core.gun
+                this.db.gun
                     .user()
                     .get("crypto-identities")
                     .once((data) => {
@@ -344,7 +345,7 @@ class CryptoIdentityManager {
                 };
             }
             // Ottieni il SEA pair dell'utente corrente
-            const userInstance = this.core.gun.user();
+            const userInstance = this.db.gun.user();
             const seaPair = userInstance?._?.sea;
             if (!seaPair) {
                 return {