Fix: Implement complete fix

src/lib/authStorage.ts

@@ -6,6 +6,7 @@ class AuthStorage {
   private storage: Storage | null = null;
   private memoryStorage: Map<string, string> = new Map();
   private storageType: 'localStorage' | 'sessionStorage' | 'memory' = 'memory';
+  private sessionRecoveryAttempted = false;
 
   constructor() {
     // Try localStorage first
@@ -28,32 +29,113 @@ class AuthStorage {
         this.storageType = 'memory';
         console.error('[AuthStorage] Both localStorage and sessionStorage blocked, using in-memory storage ⛔');
         console.error('[AuthStorage] Sessions will NOT persist across page reloads!');
+        
+        // Attempt to recover session from URL
+        this.attemptSessionRecoveryFromURL();
       }
     }
+
+    // Listen for storage events to sync across tabs (when possible)
+    if (this.storage) {
+      window.addEventListener('storage', this.handleStorageChange.bind(this));
+    }
+  }
+
+  private attemptSessionRecoveryFromURL() {
+    if (this.sessionRecoveryAttempted) return;
+    this.sessionRecoveryAttempted = true;
+
+    try {
+      const urlParams = new URLSearchParams(window.location.hash.substring(1));
+      const accessToken = urlParams.get('access_token');
+      const refreshToken = urlParams.get('refresh_token');
+      
+      if (accessToken && refreshToken) {
+        console.log('[AuthStorage] Recovering session from URL parameters');
+        // Store in memory
+        this.memoryStorage.set('sb-auth-token', JSON.stringify({
+          access_token: accessToken,
+          refresh_token: refreshToken,
+          expires_at: Date.now() + 3600000, // 1 hour
+        }));
+        
+        // Clean URL
+        window.history.replaceState({}, document.title, window.location.pathname);
+      }
+    } catch (error) {
+      console.error('[AuthStorage] Failed to recover session from URL:', error);
+    }
+  }
+
+  private handleStorageChange(event: StorageEvent) {
+    // Sync auth state across tabs
+    if (event.key?.startsWith('sb-') && event.newValue) {
+      console.log('[AuthStorage] Syncing auth state across tabs');
+    }
   }
 
   getItem(key: string): string | null {
-    if (this.storage) {
-      return this.storage.getItem(key);
+    try {
+      if (this.storage) {
+        const value = this.storage.getItem(key);
+        if (value) {
+          // Verify it's not expired
+          if (key.includes('auth-token')) {
+            try {
+              const parsed = JSON.parse(value);
+              if (parsed.expires_at && parsed.expires_at < Date.now()) {
+                console.warn('[AuthStorage] Token expired, removing');
+                this.removeItem(key);
+                return null;
+              }
+            } catch {}
+          }
+        }
+        return value;
+      }
+      return this.memoryStorage.get(key) || null;
+    } catch (error) {
+      console.error('[AuthStorage] Error reading from storage:', error);
+      return this.memoryStorage.get(key) || null;
     }
-    return this.memoryStorage.get(key) || null;
   }
 
   setItem(key: string, value: string): void {
-    if (this.storage) {
-      this.storage.setItem(key, value);
-    } else {
+    try {
+      if (this.storage) {
+        this.storage.setItem(key, value);
+      }
+      // Always keep in memory as backup
+      this.memoryStorage.set(key, value);
+    } catch (error) {
+      console.error('[AuthStorage] Error writing to storage:', error);
+      // Fallback to memory only
       this.memoryStorage.set(key, value);
     }
   }
 
   removeItem(key: string): void {
-    if (this.storage) {
-      this.storage.removeItem(key);
-    } else {
+    try {
+      if (this.storage) {
+        this.storage.removeItem(key);
+      }
+      this.memoryStorage.delete(key);
+    } catch (error) {
+      console.error('[AuthStorage] Error removing from storage:', error);
       this.memoryStorage.delete(key);
     }
   }
+
+  // Get storage status for diagnostics
+  getStorageStatus(): { type: string; persistent: boolean; warning: string | null } {
+    return {
+      type: this.storageType,
+      persistent: this.storageType !== 'memory',
+      warning: this.storageType === 'memory' 
+        ? 'Sessions will not persist across page reloads. Please enable cookies/storage for this site.'
+        : null
+    };
+  }
 }
 
 export const authStorage = new AuthStorage();