reaper-arcade-hub 1.0.0

package/js/firebase-client.js

@@ -0,0 +1,427 @@
+// REAPER HUB - Firebase Realtime Engine, Live Chat & Server Security Service
+
+const firebaseConfig = {
+  apiKey: "AIzaSyBuLsNUpp1DAGWI9cKni_MZJQsgB97xfHA",
+  authDomain: "gabasd-69d8a.firebaseapp.com",
+  databaseURL: "https://gabasd-69d8a-default-rtdb.firebaseio.com",
+  projectId: "gabasd-69d8a",
+  storageBucket: "gabasd-69d8a.firebasestorage.app",
+  messagingSenderId: "1088727880080",
+  appId: "1:1088727880080:web:b7765ab900e4c1dd492315",
+  measurementId: "G-S8PPR0SBKL"
+};
+
+class FirebaseService {
+  constructor() {
+    this.app = null;
+    this.db = null;
+    this.isInitialized = false;
+  }
+
+  async init() {
+    try {
+      if (typeof firebase !== 'undefined' && firebase.initializeApp) {
+        if (!firebase.apps.length) {
+          this.app = firebase.initializeApp(firebaseConfig);
+        } else {
+          this.app = firebase.app();
+        }
+        this.db = firebase.database();
+        this.isInitialized = true;
+        console.log("[REAPER HUB] Realtime DB Connected successfully.");
+      }
+    } catch (e) {
+      console.warn("[REAPER HUB] Firebase init error:", e);
+    }
+  }
+
+  // Realtime Live Chat
+  listenChatMessages(callback) {
+    if (this.db) {
+      try {
+        const chatRef = this.db.ref("reaperChat").limitToLast(60);
+        chatRef.on("value", (snapshot) => {
+          const val = snapshot.val();
+          let messages = [];
+          if (val) {
+            messages = Object.values(val);
+            messages.sort((a, b) => (a.timestamp || 0) - (b.timestamp || 0));
+          }
+          callback(messages);
+        }, (error) => {
+          console.error("[REAPER CHAT ERROR]", error);
+          const localChat = JSON.parse(localStorage.getItem("reaper_local_chat") || "[]");
+          callback(localChat);
+        });
+      } catch (err) {
+        const localChat = JSON.parse(localStorage.getItem("reaper_local_chat") || "[]");
+        callback(localChat);
+      }
+    } else {
+      const localChat = JSON.parse(localStorage.getItem("reaper_local_chat") || "[]");
+      callback(localChat);
+    }
+  }
+
+  async sendChatMessage(msgData) {
+    const msgId = 'msg_' + Date.now() + '_' + Math.random().toString(36).substring(2, 6);
+    msgData.id = msgId;
+
+    const localChat = JSON.parse(localStorage.getItem("reaper_local_chat") || "[]");
+    localChat.push(msgData);
+    if (localChat.length > 80) localChat.shift();
+    localStorage.setItem("reaper_local_chat", JSON.stringify(localChat));
+
+    if (this.db) {
+      try {
+        await this.db.ref(`reaperChat/${msgId}`).set(msgData);
+      } catch (e) {
+        console.error("[REAPER CHAT SEND ERROR]", e);
+      }
+    }
+    return true;
+  }
+
+  async deleteChatMessage(msgId) {
+    let localChat = JSON.parse(localStorage.getItem("reaper_local_chat") || "[]");
+    localChat = localChat.filter(m => m.id !== msgId);
+    localStorage.setItem("reaper_local_chat", JSON.stringify(localChat));
+
+    if (this.db) {
+      try {
+        await this.db.ref(`reaperChat/${msgId}`).remove();
+      } catch (e) {
+        console.error("[REAPER CHAT DELETE ERROR]", e);
+      }
+    }
+    return true;
+  }
+
+  listenChatLock(callback) {
+    if (this.db) {
+      try {
+        this.db.ref("reaperChatLocked").on("value", (snap) => {
+          callback(Boolean(snap.val()));
+        });
+      } catch (e) {}
+    }
+  }
+
+  async setChatLock(isLocked) {
+    localStorage.setItem("reaper_chat_locked", isLocked ? 'true' : 'false');
+    if (this.db) {
+      try {
+        await this.db.ref("reaperChatLocked").set(isLocked);
+      } catch (e) {}
+    }
+  }
+
+  // Realtime Bans & Leaderboard Progress Purge
+  listenBannedUsers(callback) {
+    if (this.db) {
+      try {
+        this.db.ref("reaperBannedUsers").on("value", (snap) => {
+          const bans = snap.val() || {};
+          const bannedList = Object.keys(bans);
+          localStorage.setItem('reaper_banned_users', JSON.stringify(bannedList));
+          callback(bannedList);
+        });
+      } catch (e) {
+        const local = JSON.parse(localStorage.getItem('reaper_banned_users') || '[]');
+        callback(local);
+      }
+    } else {
+      const local = JSON.parse(localStorage.getItem('reaper_banned_users') || '[]');
+      callback(local);
+    }
+  }
+
+  async banUser(username) {
+    if (!username || username === 'owner') return;
+
+    if (this.db) {
+      try {
+        await this.db.ref(`reaperBannedUsers/${username}`).set(true);
+        await this.db.ref(`reaperPlaytime/${username}`).remove();
+        const chatSnap = await this.db.ref('reaperChat').once('value');
+        if (chatSnap.exists()) {
+          const chats = chatSnap.val();
+          for (const msgId of Object.keys(chats)) {
+            if (chats[msgId].username === username) {
+              await this.db.ref(`reaperChat/${msgId}`).remove();
+            }
+          }
+        }
+      } catch (e) {
+        console.warn("Error banning user on Firebase:", e);
+      }
+    }
+
+    const localBans = JSON.parse(localStorage.getItem('reaper_banned_users') || '[]');
+    if (!localBans.includes(username)) {
+      localBans.push(username);
+      localStorage.setItem('reaper_banned_users', JSON.stringify(localBans));
+    }
+  }
+
+  async unbanUser(username) {
+    if (this.db) {
+      try {
+        await this.db.ref(`reaperBannedUsers/${username}`).remove();
+      } catch (e) {
+        console.warn("Error unbanning user on Firebase:", e);
+      }
+    }
+    const localBans = JSON.parse(localStorage.getItem('reaper_banned_users') || '[]').filter(u => u !== username);
+    localStorage.setItem('reaper_banned_users', JSON.stringify(localBans));
+  }
+
+  // Realtime Site Lockdown (Main Portal)
+  listenSiteLockdown(callback) {
+    if (this.db) {
+      try {
+        this.db.ref("reaperSiteLockdown").on("value", (snap) => {
+          const isLocked = Boolean(snap.val());
+          localStorage.setItem('reaper_site_lockdown', isLocked ? 'true' : 'false');
+          callback(isLocked);
+        });
+      } catch (e) {
+        callback(localStorage.getItem('reaper_site_lockdown') === 'true');
+      }
+    } else {
+      callback(localStorage.getItem('reaper_site_lockdown') === 'true');
+    }
+  }
+
+  async setSiteLockdown(isLocked) {
+    localStorage.setItem('reaper_site_lockdown', isLocked ? 'true' : 'false');
+    if (this.db) {
+      try {
+        await this.db.ref("reaperSiteLockdown").set(isLocked);
+      } catch (e) {}
+    }
+  }
+
+  // Realtime Verify Gateway Lockdown
+  listenVerifyLockdown(callback) {
+    if (this.db) {
+      try {
+        this.db.ref("reaperVerifyLockdown").on("value", (snap) => {
+          const isLocked = Boolean(snap.val());
+          localStorage.setItem('reaper_verify_lockdown', isLocked ? 'true' : 'false');
+          callback(isLocked);
+        });
+      } catch (e) {
+        callback(localStorage.getItem('reaper_verify_lockdown') === 'true');
+      }
+    } else {
+      callback(localStorage.getItem('reaper_verify_lockdown') === 'true');
+    }
+  }
+
+  async setVerifyLockdown(isLocked) {
+    localStorage.setItem('reaper_verify_lockdown', isLocked ? 'true' : 'false');
+    if (this.db) {
+      try {
+        await this.db.ref("reaperVerifyLockdown").set(isLocked);
+      } catch (e) {}
+    }
+  }
+
+  // Realtime Keys Pause / Freeze Lock
+  listenKeysLocked(callback) {
+    if (this.db) {
+      try {
+        this.db.ref("reaperKeysLocked").on("value", (snap) => {
+          const isLocked = Boolean(snap.val());
+          localStorage.setItem('reaper_keys_locked', isLocked ? 'true' : 'false');
+          callback(isLocked);
+        });
+      } catch (e) {
+        callback(localStorage.getItem('reaper_keys_locked') === 'true');
+      }
+    } else {
+      callback(localStorage.getItem('reaper_keys_locked') === 'true');
+    }
+  }
+
+  async setKeysLocked(isLocked) {
+    localStorage.setItem('reaper_keys_locked', isLocked ? 'true' : 'false');
+    if (this.db) {
+      try {
+        await this.db.ref("reaperKeysLocked").set(isLocked);
+      } catch (e) {}
+    }
+  }
+
+  // Realtime Emergency Google Redirect Lock (Panic Mode)
+  listenRedirectGoogle(callback) {
+    if (this.db) {
+      try {
+        this.db.ref("reaperRedirectGoogle").on("value", (snap) => {
+          const isRedirect = Boolean(snap.val());
+          localStorage.setItem('reaper_redirect_google', isRedirect ? 'true' : 'false');
+          callback(isRedirect);
+        });
+      } catch (e) {
+        callback(localStorage.getItem('reaper_redirect_google') === 'true');
+      }
+    } else {
+      callback(localStorage.getItem('reaper_redirect_google') === 'true');
+    }
+  }
+
+  async setRedirectGoogle(isRedirect) {
+    localStorage.setItem('reaper_redirect_google', isRedirect ? 'true' : 'false');
+    if (this.db) {
+      try {
+        await this.db.ref("reaperRedirectGoogle").set(isRedirect);
+      } catch (e) {}
+    }
+  }
+
+  // Permanent Shutdown Mode ("WE ARE SHUTTING DOWN FOR GOOD")
+  listenShutdownMode(callback) {
+    if (this.db) {
+      try {
+        this.db.ref("reaperShutdownMode").on("value", (snap) => {
+          const isShutdown = Boolean(snap.val());
+          localStorage.setItem('reaper_shutdown_mode', isShutdown ? 'true' : 'false');
+          callback(isShutdown);
+        });
+      } catch (e) {}
+    }
+  }
+
+  async setShutdownMode(isShutdown) {
+    localStorage.setItem('reaper_shutdown_mode', isShutdown ? 'true' : 'false');
+    if (this.db) {
+      try {
+        await this.db.ref("reaperShutdownMode").set(isShutdown);
+      } catch (e) {}
+    }
+  }
+
+  // Purge All Server Data
+  async purgeAllServerData() {
+    if (this.db) {
+      try {
+        await this.db.ref('reaperChat').remove();
+        await this.db.ref('reaperPlaytime').remove();
+        await this.db.ref('reaperGeneratedKeys').remove();
+        await this.db.ref('reaperTimeouts').remove();
+      } catch (e) {
+        console.error("Purge error on Firebase:", e);
+      }
+    }
+    localStorage.removeItem('reaper_local_chat');
+    localStorage.removeItem('reaper_generated_keys');
+  }
+
+  // Cross-Domain Realtime Key Management
+  listenGeneratedKeys(callback) {
+    if (this.db) {
+      try {
+        this.db.ref("reaperGeneratedKeys").on("value", (snap) => {
+          const keys = snap.val() || {};
+          localStorage.setItem('reaper_generated_keys', JSON.stringify(keys));
+          callback(keys);
+        });
+      } catch (e) {
+        const local = JSON.parse(localStorage.getItem('reaper_generated_keys') || '{}');
+        callback(local);
+      }
+    } else {
+      const local = JSON.parse(localStorage.getItem('reaper_generated_keys') || '{}');
+      callback(local);
+    }
+  }
+
+  async saveKey(keyName, keyInfo) {
+    const local = JSON.parse(localStorage.getItem('reaper_generated_keys') || '{}');
+    local[keyName] = keyInfo;
+    localStorage.setItem('reaper_generated_keys', JSON.stringify(local));
+
+    if (this.db) {
+      try {
+        await this.db.ref(`reaperGeneratedKeys/${keyName}`).set(keyInfo);
+      } catch (e) {
+        console.warn("Error saving key to Firebase:", e);
+      }
+    }
+  }
+
+  async deleteKey(keyName) {
+    const local = JSON.parse(localStorage.getItem('reaper_generated_keys') || '{}');
+    delete local[keyName];
+    localStorage.setItem('reaper_generated_keys', JSON.stringify(local));
+
+    if (this.db) {
+      try {
+        await this.db.ref(`reaperGeneratedKeys/${keyName}`).remove();
+      } catch (e) {
+        console.warn("Error deleting key from Firebase:", e);
+      }
+    }
+  }
+
+  async fetchKeyInfo(keyName) {
+    if (!keyName) return null;
+    const cleanKey = keyName.trim().toUpperCase();
+
+    if (this.db) {
+      try {
+        // 1. Direct match
+        let snap = await this.db.ref(`reaperGeneratedKeys/${cleanKey}`).once('value');
+        if (snap.exists()) return snap.val();
+
+        // 2. Prefixed with REAPER-
+        if (!cleanKey.startsWith('REAPER-')) {
+          snap = await this.db.ref(`reaperGeneratedKeys/REAPER-${cleanKey}`).once('value');
+          if (snap.exists()) return snap.val();
+        }
+
+        // 3. Case-insensitive scan across all keys
+        const allSnap = await this.db.ref('reaperGeneratedKeys').once('value');
+        if (allSnap.exists()) {
+          const allKeys = allSnap.val();
+          for (const k of Object.keys(allKeys)) {
+            if (k.toUpperCase() === cleanKey || k.toUpperCase() === 'REAPER-' + cleanKey) {
+              return allKeys[k];
+            }
+          }
+        }
+      } catch (e) {}
+    }
+
+    const local = JSON.parse(localStorage.getItem('reaper_generated_keys') || '{}');
+    if (local[cleanKey]) return local[cleanKey];
+    if (local['REAPER-' + cleanKey]) return local['REAPER-' + cleanKey];
+    for (const k of Object.keys(local)) {
+      if (k.toUpperCase() === cleanKey || k.toUpperCase() === 'REAPER-' + cleanKey) {
+        return local[k];
+      }
+    }
+    return null;
+  }
+
+  async incrementKeyUsage(keyName) {
+    if (this.db) {
+      try {
+        const keyRef = this.db.ref(`reaperGeneratedKeys/${keyName}`);
+        const snap = await keyRef.once('value');
+        if (snap.exists()) {
+          const info = snap.val();
+          const newUsed = (info.usedCount || 0) + 1;
+          if (newUsed >= (info.maxUses || 999999)) {
+            await keyRef.remove();
+          } else {
+            await keyRef.update({ usedCount: newUsed });
+          }
+        }
+      } catch (e) {}
+    }
+  }
+}
+
+window.reaperFirebase = new FirebaseService();