diff --git a/core/__init__.py b/core/__init__.py
new file mode 100644
index 0000000..06d7405
Binary files /dev/null and b/core/__init__.py differ
diff --git a/core/admin_auth.py b/core/admin_auth.py
new file mode 100644
index 0000000..f1d7198
--- /dev/null
+++ b/core/admin_auth.py
@@ -0,0 +1,148 @@
+import time
+import requests
+from requests.adapters import HTTPAdapter
+from urllib3.util.retry import Retry
+from urllib.parse import quote
+from flask import request, session
+from core.config import auth as _auth_cfg
+
+SCOPE_ADMIN = "kittyrec.admin"
+SCOPE_MOD = "kittyrec.mod"
+SCOPE_EMERGENCY = "kittyrec.emergency"
+AUTH_LOGIN_URL = _auth_cfg["login_url"]
+AUTH_ME_URL = AUTH_LOGIN_URL + "/api/account/me"
+AUTH_REFRESH_URL = AUTH_LOGIN_URL + "/api/account/refresh/session"
+EMERGENCY_LOGIN_URL = "/admin/emergency_login"
+EMERGENCY_PASSWORD = _auth_cfg["emergency_password"]
+_EMERGENCY_SESSION_TTL = 8 * 3600
+_CACHE_TTL = 86400
+
+FORCE_EMERGENCY_MODE = False
+
+_auth_down_until = 0.0
+_AUTH_DOWN_TTL = 45
+
+
+def _mark_auth_down():
+ global _auth_down_until
+ _auth_down_until = time.time() + _AUTH_DOWN_TTL
+
+
+def is_auth_server_down() -> bool:
+ return time.time() < _auth_down_until
+
+
+def probe_auth_server() -> bool:
+ if is_auth_server_down():
+ return True
+ try:
+ resp = requests.get(AUTH_ME_URL, timeout=(2, 4))
+ if resp.status_code >= 500:
+ print(f"[Admin Auth] Probe: auth server returned {resp.status_code} — marking down")
+ _mark_auth_down()
+ return True
+ return False
+ except (requests.exceptions.ConnectionError, requests.exceptions.Timeout) as e:
+ print(f"[Admin Auth] Probe: unreachable ({e}) — marking down")
+ _mark_auth_down()
+ return True
+ except Exception:
+ return False
+
+
+def _get_me(sess, token):
+ return sess.get(AUTH_ME_URL, cookies={"Authorization": token}, timeout=(2, 6))
+
+
+def _authenticate_token(token):
+ if is_auth_server_down():
+ return None, None
+
+ sess = requests.Session()
+ retry = Retry(total=1, backoff_factor=0, status_forcelist=[502, 503, 504], allowed_methods=["GET"])
+ sess.mount("https://", HTTPAdapter(max_retries=retry))
+ try:
+ resp = _get_me(sess, token)
+
+ if resp.status_code in (401, 403):
+ print("[Admin Auth] Token expired, attempting refresh...")
+ refresh = sess.get(AUTH_REFRESH_URL, cookies={"Authorization": token}, timeout=(2, 6))
+ if refresh.status_code != 200:
+ print("[Admin Auth] Refresh failed")
+ return None, []
+ new_token = refresh.cookies.get("Authorization", token)
+ resp = _get_me(sess, new_token)
+
+ if resp.status_code == 200:
+ try:
+ account = resp.json()
+ except Exception:
+ _mark_auth_down()
+ return None, None
+ scopes = account.get("scopes", [])
+ session["admin_cache"] = {
+ "account": account,
+ "scopes": scopes,
+ "token_hint": token[-16:],
+ "cached_at": time.time(),
+ }
+ return account, scopes
+ elif resp.status_code >= 500:
+ print(f"[Admin Auth] Auth server returned {resp.status_code} — treating as down")
+ _mark_auth_down()
+ return None, None
+ except (requests.exceptions.ConnectionError, requests.exceptions.Timeout) as e:
+ print(f"[Admin Auth] Auth server unreachable: {e}")
+ _mark_auth_down()
+ return None, None
+ except Exception as e:
+ print(f"[Admin Auth] {e}")
+ finally:
+ sess.close()
+ return None, []
+
+
+def _get_cached(token):
+ cache = session.get("admin_cache")
+ if not cache:
+ return None, None
+ if time.time() - cache.get("cached_at", 0) > _CACHE_TTL:
+ session.pop("admin_cache", None)
+ return None, None
+ if cache.get("token_hint") != token[-16:]:
+ session.pop("admin_cache", None)
+ return None, None
+ return cache["account"], cache["scopes"]
+
+
+def get_admin_account():
+ if FORCE_EMERGENCY_MODE:
+ return {"username": "Emergency", "scopes": [SCOPE_ADMIN]}, [SCOPE_ADMIN]
+
+ emerg = session.get("emergency_admin")
+ if emerg and emerg.get("expires", 0) > time.time():
+ return {"username": "Emergency", "scopes": [SCOPE_ADMIN]}, [SCOPE_ADMIN]
+
+ token = request.cookies.get("Authorization") or request.headers.get("Authorization")
+ if not token:
+ if is_auth_server_down():
+ return None, None
+ return None, []
+
+ account, scopes = _get_cached(token)
+ if account is not None:
+ return account, scopes
+
+ return _authenticate_token(token)
+
+
+def has_any_admin_scope(scopes):
+ if scopes is None:
+ return False
+ return SCOPE_ADMIN in scopes or SCOPE_MOD in scopes
+
+
+def make_login_redirect(target_url=None):
+ url = target_url or request.url
+ url = url.replace("http://", "https://", 1)
+ return AUTH_LOGIN_URL + "?redirect=" + quote(url, safe="")
diff --git a/core/admin_panel.py b/core/admin_panel.py
new file mode 100644
index 0000000..2cd5cc4
--- /dev/null
+++ b/core/admin_panel.py
@@ -0,0 +1,2020 @@
+
+import time
+
+from flask import redirect, request, flash, url_for
+from flask_admin import Admin, AdminIndexView, BaseView, expose
+from flask_admin.contrib.sqla import ModelView
+from flask_admin.actions import action
+import json
+from markupsafe import Markup
+
+from core.admin_auth import (
+ get_admin_account, has_any_admin_scope,
+ SCOPE_ADMIN, SCOPE_MOD, make_login_redirect,
+ probe_auth_server, EMERGENCY_LOGIN_URL,
+)
+from core.state import db as game_db, ws_registry, session_mgr
+from core.ban_service import kick_player, cascade_ban, cascade_unban
+from core.models import sql_db, Profile, Gift, BanLog, Room, AdminTodo, AdminIssue
+
+
+class _AuthMixin:
+ def is_accessible(self):
+ account, scopes = get_admin_account()
+ return account is not None and has_any_admin_scope(scopes)
+
+ def inaccessible_callback(self, name, **kwargs):
+ if probe_auth_server():
+ return redirect(EMERGENCY_LOGIN_URL)
+ return redirect(make_login_redirect())
+
+ def _get_account(self):
+ return get_admin_account()
+
+
+class HomeView(_AuthMixin, AdminIndexView):
+ @expose("/")
+ def index(self):
+ account, scopes = get_admin_account()
+ if not account or not has_any_admin_scope(scopes):
+ return redirect(make_login_redirect())
+
+ game_db.log_admin_action(
+ account["username"], "login",
+ f"Admin panel login",
+ request.headers.get("X-Forwarded-For", request.remote_addr or ""),
+ )
+ try:
+ from core.discord import send_admin
+ send_admin(
+ title="Admin Login",
+ color=0x3498DB,
+ fields=[{"name": "Admin", "value": account["username"], "inline": True},
+ {"name": "IP", "value": request.headers.get("X-Forwarded-For", request.remote_addr or "?"), "inline": True}],
+ )
+ except Exception:
+ pass
+
+ import datetime as _dt
+ today = _dt.datetime.utcnow()
+ today_start = today.strftime("%Y-%m-%d 00:00:00")
+ today_end = today.strftime("%Y-%m-%d 23:59:59")
+ conn = game_db._get_conn()
+ pending_gifts = conn.execute("SELECT COUNT(*) AS c FROM gifts WHERE consumed=0").fetchone()["c"]
+ banned_count = conn.execute("SELECT COUNT(*) AS c FROM profiles WHERE banned=1").fetchone()["c"]
+ total_players = conn.execute("SELECT COUNT(*) AS c FROM profiles").fetchone()["c"]
+ admin_logins_today = conn.execute(
+ "SELECT COUNT(*) AS c FROM admin_action_log WHERE action='login' AND created_at BETWEEN ? AND ?",
+ (today_start, today_end),
+ ).fetchone()["c"]
+ recent_actions = game_db.get_admin_action_log(limit=25)
+
+ online_ids = ws_registry.connected_ids()
+ profiles_map = game_db.get_profiles_batch(online_ids)
+ online_players = []
+ for pid in online_ids:
+ p = profiles_map.get(pid)
+ if p:
+ s = session_mgr.get_player_session(pid)
+ online_players.append({
+ "id": p["Id"],
+ "username": p["Username"],
+ "display_name": p["DisplayName"],
+ "level": p["Level"],
+ "room": s.name if s else "Lobby",
+ "developer": p.get("Developer", False),
+ "screen_mode": ws_registry.is_screen_mode(pid),
+ })
+
+ active_sessions = session_mgr.all_public_sessions()
+
+ return self.render(
+ "admin/index.html",
+ online_count=len(ws_registry.connected_ids()),
+ session_count=len(active_sessions),
+ total_players=total_players,
+ pending_gifts=pending_gifts,
+ banned_count=banned_count,
+ admin_logins_today=admin_logins_today,
+ online_players=online_players,
+ recent_actions=recent_actions,
+ active_sessions=active_sessions,
+ account=account,
+ scopes=scopes,
+ SCOPE_ADMIN=SCOPE_ADMIN,
+ )
+
+
+_RARITY_LABELS = {0: "Common", 1: "Uncommon", 2: "Rare", 3: "Epic", 4: "Legendary", 5: "Mythic"}
+_CONTEXT_LABELS = {0: "Admin", 1: "Activity", 2: "Store", 3: "LevelUp"}
+
+
+class ProfileView(_AuthMixin, ModelView):
+ column_list = ["id", "username", "display_name", "level", "xp", "tokens",
+ "developer", "banned", "ban_reason", "created_at"]
+ column_searchable_list = ["username", "display_name", "platform_id"]
+ column_filters = ["banned", "developer", "level", "platform"]
+ column_sortable_list = ["id", "username", "level", "xp", "tokens", "banned", "developer", "created_at"]
+ column_default_sort = ("id", False)
+ column_editable_list = ["tokens", "xp", "level", "developer", "banned"]
+ can_delete = False
+ can_create = False
+ page_size = 50
+ form_excluded_columns = ["password", "gifts", "ban_logs", "created_at"]
+ column_labels = {
+ "display_name": "Display Name",
+ "ban_reason": "Ban Reason",
+ "banned_until": "Banned Until",
+ "banned_by": "Banned By",
+ "created_at": "Joined",
+ "platform_id": "Platform ID",
+ }
+ column_formatters = {
+ "developer": lambda v, c, m, p: Markup('★ Dev') if m.developer else "",
+ "banned": lambda v, c, m, p: Markup('⛔ Banned') if m.banned else Markup('✓ OK'),
+ "username": lambda v, c, m, p: Markup(
+ f'{m.username}
'
+ f'{m.display_name}
'
+ f'🎁 Gift Item'
+ ),
+ }
+ column_extra_row_actions = []
+
+ def after_model_change(self, form, model, is_created):
+ if is_created:
+ return
+ account, _ = get_admin_account()
+ name = account.get("username", "admin") if account else "admin"
+ changed_fields = [f for f in form.data if f not in ("csrf_token",) and getattr(model, f, None) is not None]
+ game_db.log_admin_action(name, "edit_profile",
+ f"Edited profile {model.username} (id={model.id}): fields={', '.join(changed_fields)}",
+ request.headers.get("X-Forwarded-For", request.remote_addr or ""))
+ if getattr(model, "banned", False):
+ reason = model.ban_reason or "Admin ban (inline)"
+ cascade_ban(model.id, reason, 0, name)
+ else:
+ cascade_unban(model.id, name)
+
+ def _ip(self):
+ return request.headers.get("X-Forwarded-For", request.remote_addr or "")
+
+ @action("ban_1h", "Ban (1 hour)")
+ def action_ban_1h(self, ids):
+ account, _ = self._get_account()
+ name = account.get("username", "admin") if account else "admin"
+ reason = (request.form.get("ban_reason") or "Admin ban")[:256]
+ for id in ids:
+ p = game_db.get_profile(int(id))
+ game_db.ban_player(int(id), reason=reason, duration_hours=1, admin_name=name)
+ cascade_ban(int(id), reason, 1, name)
+ game_db.log_admin_action(name, "ban_1h", f"Banned {p['Username'] if p else id}: {reason}", self._ip())
+ try:
+ from core.discord import send_admin
+ names = ", ".join(game_db.get_profile(int(i))["Username"] for i in ids if game_db.get_profile(int(i)))
+ send_admin(title="Players Banned (1h)", color=0xE74C3C,
+ fields=[{"name": "Players", "value": names or str(ids), "inline": False},
+ {"name": "Reason", "value": reason, "inline": False},
+ {"name": "By", "value": name, "inline": True}])
+ except Exception:
+ pass
+ flash(f"Banned {len(ids)} player(s) for 1 hour.", "success")
+
+ @action("ban_day", "Ban (1 day)")
+ def action_ban_day(self, ids):
+ account, _ = self._get_account()
+ name = account.get("username", "admin") if account else "admin"
+ reason = (request.form.get("ban_reason") or "Admin ban")[:256]
+ for id in ids:
+ p = game_db.get_profile(int(id))
+ game_db.ban_player(int(id), reason=reason, duration_hours=24, admin_name=name)
+ cascade_ban(int(id), reason, 24, name)
+ game_db.log_admin_action(name, "ban_1d", f"Banned {p['Username'] if p else id}: {reason}", self._ip())
+ try:
+ from core.discord import send_admin
+ names = ", ".join(game_db.get_profile(int(i))["Username"] for i in ids if game_db.get_profile(int(i)))
+ send_admin(title="Players Banned (24h)", color=0xE74C3C,
+ fields=[{"name": "Players", "value": names or str(ids), "inline": False},
+ {"name": "Reason", "value": reason, "inline": False},
+ {"name": "By", "value": name, "inline": True}])
+ except Exception:
+ pass
+ flash(f"Banned {len(ids)} player(s) for 24 hours.", "success")
+
+ @action("ban_week", "Ban (1 week)")
+ def action_ban_week(self, ids):
+ account, _ = self._get_account()
+ name = account.get("username", "admin") if account else "admin"
+ reason = (request.form.get("ban_reason") or "Admin ban")[:256]
+ for id in ids:
+ p = game_db.get_profile(int(id))
+ game_db.ban_player(int(id), reason=reason, duration_hours=168, admin_name=name)
+ cascade_ban(int(id), reason, 168, name)
+ game_db.log_admin_action(name, "ban_1w", f"Banned {p['Username'] if p else id}: {reason}", self._ip())
+ try:
+ from core.discord import send_admin
+ names = ", ".join(game_db.get_profile(int(i))["Username"] for i in ids if game_db.get_profile(int(i)))
+ send_admin(title="Players Banned (1 week)", color=0xE74C3C,
+ fields=[{"name": "Players", "value": names or str(ids), "inline": False},
+ {"name": "Reason", "value": reason, "inline": False},
+ {"name": "By", "value": name, "inline": True}])
+ except Exception:
+ pass
+ flash(f"Banned {len(ids)} player(s) for 1 week.", "success")
+
+ @action("permaban", "Permanent Ban")
+ def action_permaban(self, ids):
+ account, scopes = self._get_account()
+ if SCOPE_ADMIN not in scopes:
+ flash("Requires kittyrec.admin scope.", "error")
+ return
+ name = account.get("username", "admin") if account else "admin"
+ reason = (request.form.get("ban_reason") or "Permanent ban")[:256]
+ for id in ids:
+ p = game_db.get_profile(int(id))
+ game_db.ban_player(int(id), reason=reason, duration_hours=0, admin_name=name)
+ cascade_ban(int(id), reason, 0, name)
+ game_db.log_admin_action(name, "permaban", f"Permabanned {p['Username'] if p else id}: {reason}", self._ip())
+ try:
+ from core.discord import send_admin
+ names = ", ".join(game_db.get_profile(int(i))["Username"] for i in ids if game_db.get_profile(int(i)))
+ send_admin(title="Players Permabanned", color=0x7F0000,
+ fields=[{"name": "Players", "value": names or str(ids), "inline": False},
+ {"name": "Reason", "value": reason, "inline": False},
+ {"name": "By", "value": name, "inline": True}])
+ except Exception:
+ pass
+ flash(f"Permanently banned {len(ids)} player(s).", "success")
+
+ @action("unban", "Unban", "Unban selected players?")
+ def action_unban(self, ids):
+ account, scopes = self._get_account()
+ if SCOPE_ADMIN not in scopes:
+ flash("Requires kittyrec.admin scope.", "error")
+ return
+ name = account.get("username", "admin") if account else "admin"
+ from core.anticheat import reset_offenses
+ for id in ids:
+ p = game_db.get_profile(int(id))
+ cascade_unban(int(id), name)
+ reset_offenses(int(id))
+ game_db.log_admin_action(name, "unban", f"Unbanned {p['Username'] if p else id}", self._ip())
+ try:
+ from core.discord import send_admin
+ names = ", ".join(game_db.get_profile(int(i))["Username"] for i in ids if game_db.get_profile(int(i)))
+ send_admin(title="Players Unbanned", color=0x2ECC71,
+ fields=[{"name": "Players", "value": names or str(ids), "inline": False},
+ {"name": "By", "value": name, "inline": True}])
+ except Exception:
+ pass
+ flash(f"Unbanned {len(ids)} player(s).", "success")
+
+ @action("toggle_dev", "Toggle Developer", "Toggle developer flag?")
+ def action_toggle_dev(self, ids):
+ account, scopes = self._get_account()
+ if SCOPE_ADMIN not in scopes:
+ flash("Requires kittyrec.admin scope.", "error")
+ return
+ name = account.get("username", "admin") if account else "admin"
+ for id in ids:
+ p = game_db.get_profile(int(id))
+ if p:
+ game_db.set_developer(int(id), not p.get("Developer"))
+ game_db.log_admin_action(name, "toggle_dev", f"Toggled dev for {p['Username']}", self._ip())
+ flash(f"Toggled developer for {len(ids)} player(s).", "success")
+
+ @action("disconnect", "Disconnect (WebSocket)", "Disconnect WebSocket for selected players?")
+ def action_disconnect(self, ids):
+ account, _ = self._get_account()
+ name = account.get("username", "admin") if account else "admin"
+ for id in ids:
+ p = game_db.get_profile(int(id))
+ kick_player(int(id))
+ game_db.log_admin_action(name, "disconnect", f"Disconnected {p['Username'] if p else id}", self._ip())
+ flash(f"Disconnected {len(ids)} player(s).", "success")
+
+ @action("gift_xp", "Gift 1000 XP", "Send 1000 XP gift to selected players?")
+ def action_gift_xp(self, ids):
+ account, scopes = self._get_account()
+ if SCOPE_ADMIN not in scopes:
+ flash("Requires kittyrec.admin scope.", "error")
+ return
+ name = account.get("username", "admin") if account else "admin"
+ from core.ws_helpers import push_gift
+ for id in ids:
+ p = game_db.get_profile(int(id))
+ gift = game_db.add_gift(int(id), xp=1000, gift_rarity=10,
+ message="Gift from KittyRec admin", gift_context=0)
+ push_gift(int(id), gift)
+ game_db.log_admin_action(name, "gift_xp", f"Gifted 1000 XP to {p['Username'] if p else id}", self._ip())
+ flash(f"Sent 1000 XP gift to {len(ids)} player(s).", "success")
+
+ @action("gift_tokens", "Gift 100 Tokens", "Send 100 RecCenterTokens to selected players?")
+ def action_gift_tokens(self, ids):
+ account, scopes = self._get_account()
+ if SCOPE_ADMIN not in scopes:
+ flash("Requires kittyrec.admin scope.", "error")
+ return
+ name = account.get("username", "admin") if account else "admin"
+ from core.ws_helpers import push_gift
+ for id in ids:
+ p = game_db.get_profile(int(id))
+ gift = game_db.add_gift(int(id), gift_rarity=10, currency_type=2, currency=100,
+ message="Tokens from KittyRec admin", gift_context=0)
+ push_gift(int(id), gift)
+ game_db.log_admin_action(name, "gift_tokens", f"Gifted 100 tokens to {p['Username'] if p else id}", self._ip())
+ flash(f"Sent 100 tokens to {len(ids)} player(s).", "success")
+
+ @action("reset_password", "Reset Password", "Generate a new temp password and DM it to selected players?")
+ def action_reset_password(self, ids):
+ account, scopes = self._get_account()
+ if SCOPE_ADMIN not in scopes:
+ flash("Requires kittyrec.admin scope.", "error")
+ return
+ name = account.get("username", "admin") if account else "admin"
+ import secrets, string
+ from werkzeug.security import generate_password_hash
+ _KITTYREC_PID = 23
+ alphabet = string.ascii_letters + string.digits
+ for id in ids:
+ pid = int(id)
+ p = game_db.get_profile(pid)
+ if not p:
+ continue
+ temp_pass = "".join(secrets.choice(alphabet) for _ in range(8))
+ conn = game_db._get_conn()
+ conn.execute("UPDATE profiles SET password=? WHERE id=?",
+ (generate_password_hash(temp_pass), pid))
+ conn.commit()
+ username = p.get("Username", f"Player{pid}")
+ thread_id = game_db.get_or_create_chat([_KITTYREC_PID, pid])
+ msg_text = (
+ f"Your password has been reset by an admin.\n\n"
+ f"Your username: {username}\n"
+ f"Your new temp password: {temp_pass}\n\n"
+ f"Reply to this message with a new password (8+ chars) to set it!"
+ )
+ msg_id = game_db.send_chat_message(thread_id, _KITTYREC_PID, msg_text)
+ msg = game_db.get_chat_message(msg_id)
+ ws_registry.send(pid, {"Id": 90, "Msg": msg})
+ game_db.log_admin_action(name, "reset_password", f"Reset password for {username} (id={pid})", self._ip())
+ print(f"[Admin] {name} reset password for pid={pid} ({username})")
+ flash(f"Reset password for {len(ids)} player(s) and sent DM.", "success")
+
+ @action("temp_password", "Get Temp Password", "Generate a temp password and show it here (for offline players)?")
+ def action_temp_password(self, ids):
+ account, scopes = self._get_account()
+ if SCOPE_ADMIN not in scopes:
+ flash("Requires kittyrec.admin scope.", "error")
+ return
+ name = account.get("username", "admin") if account else "admin"
+ import secrets, string
+ from werkzeug.security import generate_password_hash
+ alphabet = string.ascii_letters + string.digits
+ results = []
+ for id in ids:
+ pid = int(id)
+ p = game_db.get_profile(pid)
+ if not p:
+ continue
+ temp_pass = "".join(secrets.choice(alphabet) for _ in range(10))
+ conn = game_db._get_conn()
+ conn.execute("UPDATE profiles SET password=? WHERE id=?",
+ (generate_password_hash(temp_pass), pid))
+ conn.commit()
+ username = p.get("Username", f"Player{pid}")
+ results.append(f"{username}: {temp_pass}")
+ game_db.log_admin_action(name, "temp_password", f"Generated temp password for {username} (id={pid})", self._ip())
+ print(f"[Admin] {name} generated temp password for pid={pid} ({username})")
+ if results:
+ creds = " | ".join(results)
+ flash(Markup(f'Temp passwords generated — {creds}'), "success")
+ else:
+ flash("No valid players selected.", "warning")
+
+ @action("send_notification", "Send Notification", "Send an in-game notification to selected players?")
+ def action_send_notification(self, ids):
+ account, scopes = self._get_account()
+ if not has_any_admin_scope(scopes):
+ flash("Requires admin or mod scope.", "error")
+ return
+ name = account.get("username", "admin") if account else "admin"
+ message = request.form.get("notification_message", "").strip()
+ if not message:
+ message = "Hello from KittyRec admin!"
+ from routes.portal import _send_system_message
+ sent = 0
+ for id in ids:
+ pid = int(id)
+ p = game_db.get_profile(pid)
+ if not p:
+ continue
+ _send_system_message(pid, message)
+ sent += 1
+ game_db.log_admin_action(name, "send_notification", f"Sent notification to {sent} player(s): {message[:80]}", self._ip())
+ flash(f"Sent notification to {sent} player(s).", "success")
+
+ @action("delete_accounts", "Delete Accounts", "PERMANENTLY delete selected accounts? This cannot be undone.")
+ def action_delete_accounts(self, ids):
+ account, scopes = self._get_account()
+ if SCOPE_ADMIN not in scopes:
+ flash("Requires kittyrec.admin scope.", "error")
+ return
+ name = account.get("username", "admin") if account else "admin"
+ deleted = []
+ for id in ids:
+ pid = int(id)
+ p = game_db.get_profile(pid)
+ username = p["Username"] if p else str(pid)
+ kick_player(pid)
+ game_db.delete_profile(pid)
+ game_db.log_admin_action(name, "delete_account", f"Deleted account {username} (id={pid})", self._ip())
+ deleted.append(username)
+ try:
+ from core.discord import send_admin
+ send_admin(title="Accounts Deleted", color=0xE74C3C,
+ fields=[{"name": "Accounts", "value": ", ".join(deleted) or "none", "inline": False},
+ {"name": "By", "value": name, "inline": True}])
+ except Exception:
+ pass
+ flash(f"Deleted {len(deleted)} account(s): {', '.join(deleted)}", "success")
+
+class GiftView(_AuthMixin, ModelView):
+ can_create = False
+ can_edit = False
+ can_delete = False
+ column_list = ["id", "profile_id", "xp", "gift_rarity", "avatar_item_desc",
+ "consumable_item_desc", "equipment_prefab_name", "message",
+ "gift_context", "consumed", "created_at"]
+ column_searchable_list = ["avatar_item_desc", "consumable_item_desc",
+ "equipment_prefab_name", "message"]
+ column_filters = ["consumed", "gift_rarity", "gift_context", "profile_id"]
+ column_default_sort = ("id", True)
+ page_size = 50
+ column_labels = {
+ "profile_id": "Player",
+ "gift_rarity": "Rarity",
+ "avatar_item_desc": "Avatar Item",
+ "consumable_item_desc": "Consumable",
+ "equipment_prefab_name": "Equipment",
+ "gift_context": "Context",
+ }
+ column_formatters = {
+ "gift_rarity": lambda v, c, m, p: _RARITY_LABELS.get(m.gift_rarity, str(m.gift_rarity)),
+ "gift_context": lambda v, c, m, p: _CONTEXT_LABELS.get(m.gift_context, str(m.gift_context)),
+ "consumed": lambda v, c, m, p: Markup('Opened') if m.consumed else Markup('Pending'),
+ }
+
+ def _ip(self):
+ return request.headers.get("X-Forwarded-For", request.remote_addr or "")
+
+ @expose("/gift-item/", methods=["GET", "POST"])
+ def gift_item_view(self):
+ import json, os
+ account, scopes = get_admin_account()
+ if not account or not has_any_admin_scope(scopes):
+ return redirect(make_login_redirect())
+ if SCOPE_ADMIN not in scopes:
+ flash("Requires kittyrec.admin scope.", "error")
+ return redirect(self.get_url(".index_view"))
+
+ player_id = int(request.args.get("player_id", 0) or request.form.get("player_id", 0))
+ player = game_db.get_profile(player_id) if player_id else None
+
+ data_dir = os.path.join(os.path.dirname(os.path.dirname(__file__)), "data")
+ with open(os.path.join(data_dir, "avataritems.json")) as f:
+ all_items = json.load(f)
+ custom_items_only = []
+ try:
+ with open(os.path.join(data_dir, "custom_items.json")) as f:
+ _raw_custom = json.load(f)
+ custom_items_only = [
+ dict(i, AvatarItemDesc=i["AvatarItemDesc"] if "," in i["AvatarItemDesc"] else i["AvatarItemDesc"] + ",,,")
+ for i in _raw_custom if i.get("AvatarItemDesc")
+ ]
+ all_items = all_items + custom_items_only
+ except Exception:
+ pass
+ try:
+ with open(os.path.join(data_dir, "custom_swatches.json")) as f:
+ all_items = all_items + json.load(f)
+ except Exception:
+ pass
+ try:
+ with open(os.path.join(data_dir, "consumables.json")) as f:
+ all_consumables = json.load(f)
+ except Exception:
+ all_consumables = []
+ try:
+ with open(os.path.join(data_dir, "equipment.json")) as f:
+ all_equipment = json.load(f)
+ except Exception:
+ all_equipment = []
+
+ error = None
+ success = None
+
+ if request.method == "POST":
+ gift_type = request.form.get("gift_type", "item")
+ rarity = int(request.form.get("rarity", 1) or 1)
+ message = request.form.get("message", "Gift from KittyRec admin").strip() or "Gift from KittyRec admin"
+ xp = int(request.form.get("xp", 0) or 0)
+ level = int(request.form.get("level", 0) or 0)
+ name = account.get("username", "admin")
+
+ if not player:
+ error = "Player not found."
+ elif gift_type == "tokens":
+ tokens = int(request.form.get("tokens", 0) or 0)
+ if tokens <= 0:
+ error = "Token amount must be > 0."
+ else:
+ from core.ws_helpers import push_gift
+ gift = game_db.add_gift(
+ player_id, gift_rarity=rarity, currency_type=2, currency=tokens,
+ xp=xp, level=level, message=message, gift_context=0,
+ )
+ push_gift(player_id, gift)
+ game_db.log_admin_action(name, "gift_tokens",
+ f"Gifted {tokens} tokens to {player['Username'] if player else player_id}",
+ self._ip())
+ success = f"Sent {tokens} tokens to {player['Username']}!"
+ elif gift_type == "consumable":
+ consumable_desc = request.form.get("consumable_desc", "").strip()
+ if not consumable_desc:
+ error = "Must select a consumable."
+ else:
+ from core.ws_helpers import push_gift
+ gift = game_db.add_gift(
+ player_id, xp=xp, level=level, gift_rarity=rarity,
+ consumable_item_desc=consumable_desc,
+ message=message, gift_context=0,
+ )
+ push_gift(player_id, gift)
+ game_db.log_admin_action(name, "gift_consumable",
+ f"Gifted consumable '{consumable_desc}' to {player['Username'] if player else player_id}",
+ self._ip())
+ success = f"Consumable sent to {player['Username']}!"
+ elif gift_type == "equipment":
+ equip_prefab = request.form.get("equip_prefab", "").strip()
+ equip_guid = request.form.get("equip_guid", "").strip()
+ if not equip_prefab or not equip_guid:
+ error = "Must select an equipment item."
+ else:
+ from core.ws_helpers import push_gift
+ gift = game_db.add_gift(
+ player_id, xp=xp, level=level, gift_rarity=rarity,
+ equipment_prefab_name=equip_prefab,
+ equipment_modification_guid=equip_guid,
+ message=message, gift_context=0,
+ )
+ push_gift(player_id, gift)
+ game_db.log_admin_action(name, "gift_equipment",
+ f"Gifted equipment '{equip_prefab}' to {player['Username'] if player else player_id}",
+ self._ip())
+ success = f"Equipment sent to {player['Username']}!"
+ else:
+ item_desc = request.form.get("item_desc", "").strip()
+ if not item_desc and xp <= 0 and level <= 0:
+ error = "Must provide an item, XP > 0, or level > 0."
+ else:
+ from core.ws_helpers import push_gift
+ gift = game_db.add_gift(
+ player_id, xp=xp, level=level, gift_rarity=rarity,
+ avatar_item_desc=item_desc,
+ message=message, gift_context=0,
+ )
+ push_gift(player_id, gift)
+ game_db.log_admin_action(name, "gift_item",
+ f"Gifted item '{item_desc or 'xp/level only'}' ({xp} XP, {level} levels, rarity {rarity}) to {player['Username'] if player else player_id}",
+ self._ip())
+ success = f"Gift sent to {player['Username']}!"
+
+ return self.render(
+ "admin/gift_item.html",
+ player=player,
+ player_id=player_id,
+ all_items=all_items,
+ custom_items_only=custom_items_only,
+ all_consumables=all_consumables,
+ all_equipment=all_equipment,
+ error=error,
+ success=success,
+ account=account,
+ scopes=scopes,
+ SCOPE_ADMIN=SCOPE_ADMIN,
+ )
+
+
+class BanLogView(_AuthMixin, ModelView):
+ can_create = False
+ can_edit = False
+ can_delete = False
+ column_list = ["id", "profile_id", "action", "reason", "duration_hours",
+ "banned_until", "admin_name", "created_at"]
+ column_filters = ["action", "admin_name", "profile_id"]
+ column_default_sort = ("id", True)
+ page_size = 50
+ column_labels = {
+ "profile_id": "Player",
+ "admin_name": "By Admin",
+ "duration_hours": "Duration (h)",
+ }
+ column_formatters = {
+ "action": lambda v, c, m, p: Markup(
+ f'BAN' if m.action == "ban"
+ else f'UNBAN'
+ ),
+ "duration_hours": lambda v, c, m, p: "Permanent" if m.duration_hours == 0 and m.action == "ban" else (f"{m.duration_hours}h" if m.duration_hours else "—"),
+ }
+
+
+class RoomView(_AuthMixin, ModelView):
+ can_create = False
+ can_edit = True
+ can_delete = True
+ column_list = ["id", "name", "creator_id", "activity_level_id", "is_sandbox",
+ "max_players", "special_gamemode", "accessibility", "created_at"]
+ column_searchable_list = ["name", "description", "activity_level_id"]
+ column_filters = ["is_sandbox", "accessibility", "special_gamemode"]
+ column_default_sort = ("modified_at", True)
+ column_labels = {"special_gamemode": "Gamemode Flags"}
+ form_columns = ["name", "creator_id", "description", "activity_level_id",
+ "max_players", "accessibility", "is_sandbox", "instanced",
+ "special_gamemode", "state"]
+ page_size = 50
+
+
+
+class RoomsManageView(_AuthMixin, BaseView):
+ @expose("/", methods=["GET", "POST"])
+ def index(self):
+ account, scopes = get_admin_account()
+ if not account or not has_any_admin_scope(scopes):
+ return redirect(make_login_redirect())
+
+ from core.constants import KNOWN_ACTIVITIES, specialGameMode
+
+ error = None
+ success = None
+
+ if request.method == "POST" and SCOPE_ADMIN in scopes:
+ action_type = request.form.get("action_type", "create")
+ if action_type == "create":
+ name = request.form.get("name", "").strip()[:128]
+ activity_level_id = request.form.get("activity_level_id", "").strip()
+ max_players = max(1, min(40, int(request.form.get("max_players", 10) or 10)))
+ is_sandbox = request.form.get("is_sandbox") == "1"
+ if not name:
+ error = "Room name is required."
+ elif not activity_level_id:
+ error = "Activity Level ID is required."
+ elif game_db.get_room_by_name(name):
+ error = f"A room named '{name}' already exists."
+ else:
+ room = game_db.create_room(
+ creator_id=1,
+ name=name,
+ activity_level_id=activity_level_id,
+ max_players=max_players,
+ is_sandbox=is_sandbox,
+ )
+ admin_name = account.get("username", "admin")
+ game_db.log_admin_action(admin_name, "create_room",
+ f"Created room '{name}' (id={room['RoomId']}, activity={activity_level_id})",
+ request.headers.get("X-Forwarded-For", request.remote_addr or ""))
+ success = f"Room '{name}' created (id={room['RoomId']})."
+ elif action_type == "delete":
+ room_id = int(request.form.get("room_id", 0) or 0)
+ if room_id:
+ room = game_db.get_room(room_id)
+ if room:
+ game_db.delete_room(room_id)
+ admin_name = account.get("username", "admin")
+ game_db.log_admin_action(admin_name, "delete_room",
+ f"Deleted room '{room['Name']}' (id={room_id})",
+ request.headers.get("X-Forwarded-For", request.remote_addr or ""))
+ success = f"Room deleted."
+
+ all_rooms = game_db.get_all_rooms()
+ activities = {guid: info[0] for guid, info in KNOWN_ACTIVITIES.items()}
+ for r in all_rooms:
+ alid = r.get("ActivityLevelId", "")
+ if alid and alid not in activities:
+ activities[alid] = r.get("Name", alid[:12])
+ gamemode_defaults = game_db.get_all_gamemode_defaults()
+ gamemode_flags = [{"name": m.name.replace("_", " "), "value": m.value}
+ for m in specialGameMode if m.value > 0]
+ disabled_activities = set(game_db.get_all_disabled_activities())
+
+ return self.render(
+ "admin/rooms_manage.html",
+ all_rooms=all_rooms,
+ activities=activities,
+ gamemode_defaults=gamemode_defaults,
+ gamemode_flags=gamemode_flags,
+ disabled_activities=disabled_activities,
+ error=error,
+ success=success,
+ account=account,
+ scopes=scopes,
+ SCOPE_ADMIN=SCOPE_ADMIN,
+ )
+
+
+class CdnView(_AuthMixin, BaseView):
+ @expose("/", methods=["GET"])
+ def index(self):
+ account, scopes = get_admin_account()
+ if not account or not has_any_admin_scope(scopes):
+ return redirect(make_login_redirect())
+ return self.render(
+ "admin/cdn_view.html",
+ account=account,
+ scopes=scopes,
+ SCOPE_ADMIN=SCOPE_ADMIN,
+ )
+
+
+class DownloadsView(_AuthMixin, BaseView):
+ @expose("/", methods=["GET"])
+ def index(self):
+ account, scopes = get_admin_account()
+ if not account or not has_any_admin_scope(scopes):
+ return redirect(make_login_redirect())
+ return self.render(
+ "admin/downloads_view.html",
+ account=account,
+ scopes=scopes,
+ SCOPE_ADMIN=SCOPE_ADMIN,
+ )
+
+
+class DllArchiveView(_AuthMixin, BaseView):
+ @expose("/", methods=["GET"])
+ def index(self):
+ account, scopes = get_admin_account()
+ if not account or not has_any_admin_scope(scopes):
+ return redirect(make_login_redirect())
+ return self.render(
+ "admin/dll_archive.html",
+ account=account,
+ scopes=scopes,
+ SCOPE_ADMIN=SCOPE_ADMIN,
+ )
+
+
+class SessionsView(_AuthMixin, BaseView):
+ @expose("/")
+ def index(self):
+ account, scopes = get_admin_account()
+ if not account or not has_any_admin_scope(scopes):
+ return redirect(make_login_redirect())
+
+ active = session_mgr.all_public_sessions()
+ all_pids = [pid for s in active for pid in s.players]
+ profiles_map = game_db.get_profiles_batch(all_pids)
+ details = []
+ for s in active:
+ players = [profiles_map[pid] for pid in s.players if pid in profiles_map]
+ details.append({"session": s, "players": players})
+
+ return self.render(
+ "admin/sessions_view.html",
+ details=details,
+ online_count=len(ws_registry.connected_ids()),
+ account=account,
+ scopes=scopes,
+ SCOPE_ADMIN=SCOPE_ADMIN,
+ )
+
+
+class StoreView(_AuthMixin, BaseView):
+ @expose("/", methods=["GET", "POST"])
+ def index(self):
+ account, scopes = get_admin_account()
+ if not account or not has_any_admin_scope(scopes):
+ return redirect(make_login_redirect())
+
+ from routes.storefronts import (
+ reroll_store, _current_store_items, _RARITY_PRICE,
+ _ROTATION_WINDOW_SECS, _store_seed_offset, _store_item_map,
+ )
+
+ if request.method == "POST" and SCOPE_ADMIN in scopes:
+ action_type = request.form.get("action_type", "reroll")
+ _ip = request.headers.get("X-Forwarded-For", request.remote_addr or "")
+ if action_type == "reroll":
+ offset = reroll_store()
+ game_db.log_admin_action(account.get("username", "admin"), "reroll_store",
+ f"Rerolled store (offset={offset})", _ip)
+ flash(f"Store rerolled! (seed offset: {offset})", "success")
+ elif action_type == "pin":
+ gift_drop_id = int(request.form.get("gift_drop_id", 0) or 0)
+ slot = int(request.form.get("slot", 0) or 0)
+ if gift_drop_id and 0 <= slot <= 7:
+ item = _store_item_map().get(gift_drop_id)
+ if item:
+ game_db.set_store_featured(slot, gift_drop_id)
+ game_db.log_admin_action(account.get("username", "admin"), "store_pin",
+ f"Pinned '{item['FriendlyName']}' (id={gift_drop_id}) to slot {slot}", _ip)
+ flash(f"Pinned '{item['FriendlyName']}' to slot {slot}.", "success")
+ else:
+ flash("Item not found.", "error")
+ else:
+ flash("Invalid gift_drop_id or slot (0-7).", "error")
+ elif action_type == "unpin":
+ slot = request.form.get("slot")
+ if slot == "all":
+ game_db.clear_store_featured()
+ game_db.log_admin_action(account.get("username", "admin"), "store_unpin",
+ "Cleared all pinned store slots", _ip)
+ flash("Cleared all pinned items.", "success")
+ elif slot is not None:
+ game_db.clear_store_featured(int(slot))
+ game_db.log_admin_action(account.get("username", "admin"), "store_unpin",
+ f"Unpinned store slot {slot}", _ip)
+ flash(f"Unpinned slot {slot}.", "success")
+
+ current = _current_store_items()
+ secs_left = _ROTATION_WINDOW_SECS - (int(time.time()) % _ROTATION_WINDOW_SECS)
+ featured = game_db.get_store_featured()
+ all_items = sorted(_store_item_map().values(), key=lambda x: x["FriendlyName"])
+
+ return self.render(
+ "admin/store_view.html",
+ current=current,
+ rarity_prices=_RARITY_PRICE,
+ secs_left=secs_left,
+ seed_offset=_store_seed_offset,
+ featured=featured,
+ all_items=all_items,
+ account=account,
+ scopes=scopes,
+ SCOPE_ADMIN=SCOPE_ADMIN,
+ )
+
+
+
+
+class TexturesView(_AuthMixin, BaseView):
+ _ASSET_CATEGORIES = {
+ "Texture2D": {"exts": (".png",), "label": "Textures"},
+ "Sprite": {"exts": (".png",), "label": "Sprites"},
+ "AudioClip": {"exts": (".ogg", ".wav", ".mp3", ".fsb", "."), "label": "Audio"},
+ "Font": {"exts": (".ttf", ".otf"), "label": "Fonts"},
+ "TextAsset": {"exts": (".txt", ".json", ".xml", ".bytes", "."), "label": "Text Assets"},
+ "Shader": {"exts": (".shader",), "label": "Shaders"},
+ "MonoBehaviour": {"exts": (".json",), "label": "MonoBehaviours"},
+ }
+
+ @expose("/")
+ def index(self):
+ import os
+ account, scopes = get_admin_account()
+ if not account or not has_any_admin_scope(scopes):
+ return redirect(make_login_redirect())
+
+ extracted_base = os.path.join(os.path.dirname(os.path.dirname(__file__)), "gamecode", "extracted")
+ category = request.args.get("cat", "Texture2D")
+ if category not in self._ASSET_CATEGORIES:
+ category = "Texture2D"
+
+ asset_dir = os.path.join(extracted_base, category)
+ search = request.args.get("q", "").strip().lower()
+ page = max(1, int(request.args.get("page", 1)))
+ per_page = 60
+
+ try:
+ all_files = sorted(os.listdir(asset_dir))
+ except FileNotFoundError:
+ all_files = []
+
+ if search:
+ all_files = [f for f in all_files if search in f.lower()]
+
+ total = len(all_files)
+ pages = max(1, (total + per_page - 1) // per_page)
+ page = min(page, pages)
+ files = all_files[(page - 1) * per_page: page * per_page]
+
+ cat_counts = {}
+ for cat_name in self._ASSET_CATEGORIES:
+ cat_dir = os.path.join(extracted_base, cat_name)
+ try:
+ cat_counts[cat_name] = len(os.listdir(cat_dir))
+ except FileNotFoundError:
+ cat_counts[cat_name] = 0
+
+ return self.render(
+ "admin/textures_view.html",
+ files=files,
+ search=search,
+ page=page,
+ pages=pages,
+ total=total,
+ category=category,
+ categories=self._ASSET_CATEGORIES,
+ cat_counts=cat_counts,
+ account=account,
+ scopes=scopes,
+ )
+
+
+class ConsoleView(_AuthMixin, BaseView):
+ @expose("/")
+ def index(self):
+ import os
+ log_path = os.path.join(os.path.dirname(os.path.dirname(__file__)), "server.log")
+ initial = ""
+ try:
+ with open(log_path, "rb") as f:
+ f.seek(0, 2)
+ size = f.tell()
+ start = max(0, size - 128 * 1024)
+ f.seek(start)
+ initial = f.read().decode("utf-8", errors="replace")
+ except Exception:
+ pass
+ return self.render("admin/console_view.html", initial_log=initial, initial_pos=size if initial else 0)
+
+
+class EventsView(_AuthMixin, BaseView):
+ @expose("/")
+ def index(self):
+ account, scopes = get_admin_account()
+ if not account or not has_any_admin_scope(scopes):
+ return redirect(make_login_redirect())
+ from core.constants import KNOWN_ACTIVITIES
+ activities = {guid: info[0] for guid, info in KNOWN_ACTIVITIES.items()}
+ return self.render(
+ "admin/events_view.html",
+ account=account,
+ scopes=scopes,
+ activities=activities,
+ SCOPE_ADMIN=SCOPE_ADMIN,
+ )
+
+
+class SwatchesView(_AuthMixin, BaseView):
+ @expose("/", methods=["GET", "POST"])
+ def index(self):
+ import json as _json, os as _os
+ account, scopes = get_admin_account()
+ if not account or not has_any_admin_scope(scopes):
+ return redirect(make_login_redirect())
+
+ data_dir = _os.path.join(_os.path.dirname(_os.path.dirname(__file__)), "data")
+ swatches_path = _os.path.join(data_dir, "custom_swatches.json")
+ items_path = _os.path.join(data_dir, "avataritems.json")
+
+ error = None
+ success = None
+
+ if request.method == "POST" and SCOPE_ADMIN in scopes:
+ action_type = request.form.get("action_type", "add")
+ try:
+ with open(swatches_path) as f:
+ swatches = _json.load(f)
+ except Exception:
+ swatches = []
+
+ if action_type == "add":
+ base_guid = request.form.get("base_guid", "").strip()
+ swatch_guid = request.form.get("swatch_guid", "").strip()
+ friendly_name = request.form.get("friendly_name", "").strip()
+ if not base_guid or not swatch_guid or not friendly_name:
+ error = "All fields required."
+ else:
+ desc = f"{base_guid},{swatch_guid},,"
+ if any(s["AvatarItemDesc"] == desc for s in swatches):
+ error = "Swatch already exists."
+ else:
+ swatches.append({"AvatarItemDesc": desc, "FriendlyName": friendly_name})
+ with open(swatches_path, "w") as f:
+ _json.dump(swatches, f, indent=2)
+ from routes.avatar import _reload_items_cache
+ _reload_items_cache()
+ success = f"Added swatch '{friendly_name}'."
+ elif action_type == "delete":
+ desc = request.form.get("desc", "")
+ swatches = [s for s in swatches if s["AvatarItemDesc"] != desc]
+ with open(swatches_path, "w") as f:
+ _json.dump(swatches, f, indent=2)
+ from routes.avatar import _reload_items_cache
+ _reload_items_cache()
+ success = "Swatch deleted."
+
+ try:
+ with open(swatches_path) as f:
+ swatches = _json.load(f)
+ except Exception:
+ swatches = []
+ try:
+ with open(items_path) as f:
+ base_items = _json.load(f)
+ except Exception:
+ base_items = []
+
+ return self.render(
+ "admin/swatches_view.html",
+ swatches=swatches,
+ base_items=base_items,
+ error=error,
+ success=success,
+ account=account,
+ scopes=scopes,
+ SCOPE_ADMIN=SCOPE_ADMIN,
+ )
+
+
+class AvatarItemsView(_AuthMixin, BaseView):
+ @expose("/", methods=["GET", "POST"])
+ def index(self):
+ import json as _json, os as _os
+ account, scopes = get_admin_account()
+ if not account or not has_any_admin_scope(scopes):
+ return redirect(make_login_redirect())
+
+ data_dir = _os.path.join(_os.path.dirname(_os.path.dirname(__file__)), "data")
+ custom_items_path = _os.path.join(data_dir, "custom_items.json")
+ base_items_path = _os.path.join(data_dir, "avataritems.json")
+ swatches_path = _os.path.join(data_dir, "custom_swatches.json")
+
+ error = None
+ success = None
+
+ def _load_custom():
+ try:
+ with open(custom_items_path) as f:
+ return _json.load(f)
+ except Exception:
+ return []
+
+ def _save_custom(items):
+ with open(custom_items_path, "w") as f:
+ _json.dump(items, f, indent=2)
+ from routes.avatar import _reload_items_cache
+ _reload_items_cache()
+
+ if request.method == "POST" and SCOPE_ADMIN in scopes:
+ action_type = request.form.get("action_type", "add")
+ custom = _load_custom()
+
+ if action_type == "add":
+ item_id = request.form.get("item_id", "").strip()
+ friendly_name = request.form.get("friendly_name", "").strip()[:128]
+ starter = request.form.get("starter") == "1"
+ if not item_id or not friendly_name:
+ error = "Item ID and Friendly Name are required."
+ else:
+ try:
+ with open(base_items_path) as f:
+ base_items = _json.load(f)
+ except Exception:
+ base_items = []
+ try:
+ with open(swatches_path) as f:
+ swatches = _json.load(f)
+ except Exception:
+ swatches = []
+ all_existing_guids = {
+ i.get("AvatarItemDesc", "").split(",")[0]
+ for i in base_items + swatches + custom
+ }
+ if item_id in all_existing_guids:
+ error = f"Item ID '{item_id}' already exists."
+ else:
+ custom.append({
+ "AvatarItemDesc": item_id,
+ "FriendlyName": friendly_name,
+ "Starter": starter,
+ })
+ _save_custom(custom)
+ admin_name = account.get("username", "admin")
+ game_db.log_admin_action(admin_name, "add_avatar_item",
+ f"Added avatar item '{friendly_name}' (id={item_id}, starter={starter})",
+ request.headers.get("X-Forwarded-For", request.remote_addr or ""))
+ success = f"Added '{friendly_name}'."
+
+ elif action_type == "toggle_starter":
+ item_id = request.form.get("item_id", "")
+ for item in custom:
+ if item.get("AvatarItemDesc", "").split(",")[0] == item_id:
+ item["Starter"] = not item.get("Starter", False)
+ admin_name = account.get("username", "admin")
+ game_db.log_admin_action(admin_name, "toggle_starter_item",
+ f"Toggled starter for avatar item '{item.get('FriendlyName', item_id)}' (starter={item['Starter']})",
+ request.headers.get("X-Forwarded-For", request.remote_addr or ""))
+ success = f"Starter toggled for '{item.get('FriendlyName', item_id)}'."
+ break
+ else:
+ error = "Item not found."
+ if not error:
+ _save_custom(custom)
+
+ elif action_type == "delete":
+ item_id = request.form.get("item_id", "")
+ before = len(custom)
+ custom = [i for i in custom if i.get("AvatarItemDesc", "").split(",")[0] != item_id]
+ if len(custom) < before:
+ _save_custom(custom)
+ admin_name = account.get("username", "admin")
+ game_db.log_admin_action(admin_name, "delete_avatar_item",
+ f"Deleted avatar item id={item_id}",
+ request.headers.get("X-Forwarded-For", request.remote_addr or ""))
+ success = "Item deleted."
+ else:
+ error = "Item not found."
+
+ custom = _load_custom()
+ return self.render(
+ "admin/avatar_items_view.html",
+ custom_items=custom,
+ error=error,
+ success=success,
+ account=account,
+ scopes=scopes,
+ SCOPE_ADMIN=SCOPE_ADMIN,
+ )
+
+
+class kittyrecModView(_AuthMixin, BaseView):
+ _DLLS_PATH = None
+
+ def _dlls_path(self):
+ import os as _os
+ return _os.path.join(_os.path.dirname(_os.path.dirname(__file__)), "data", "KittyRecDlls.json")
+
+ def _dlls_dir(self):
+ import os as _os
+ return _os.path.join(_os.path.dirname(_os.path.dirname(__file__)), "kittyrec_dlls")
+
+ @expose("/", methods=["GET", "POST"])
+ def index(self):
+ import os as _os, hashlib as _hashlib, uuid as _uuid
+ account, scopes = get_admin_account()
+ if not account or not has_any_admin_scope(scopes):
+ return redirect(make_login_redirect())
+
+ from core.constants import BRANCHS
+
+ error = None
+ success = None
+
+ dlls_path = self._dlls_path()
+ dlls_dir = self._dlls_dir()
+
+ try:
+ with open(dlls_path) as f:
+ dll_data = json.load(f)
+ except Exception:
+ dll_data = {k: None for k in BRANCHS}
+
+ if request.method == "POST" and SCOPE_ADMIN in scopes:
+ branch_id = request.form.get("branch_id", "").strip()
+ action_type = request.form.get("action_type", "upload")
+
+ if branch_id not in BRANCHS:
+ error = "Invalid branch."
+ elif action_type == "clear":
+ dll_data[branch_id] = None
+ with open(dlls_path, "w") as f:
+ json.dump(dll_data, f, indent=4)
+ success = f"Cleared {BRANCHS[branch_id]}."
+ elif action_type == "upload":
+ f = request.files.get("dll_file")
+ if not f or not f.filename:
+ error = "No file selected."
+ else:
+ data = f.read()
+ sha512 = _hashlib.sha512(data).hexdigest()
+ new_filename = str(_uuid.uuid4()) + ".dll"
+ dest = _os.path.join(dlls_dir, new_filename)
+ with open(dest, "wb") as out:
+ out.write(data)
+ old = dll_data.get(branch_id)
+ dll_data[branch_id] = {"file": new_filename, "hash": sha512}
+ with open(dlls_path, "w") as out:
+ json.dump(dll_data, out, indent=4)
+ if old and old.get("file"):
+ old_path = _os.path.join(dlls_dir, old["file"])
+ try:
+ _os.remove(old_path)
+ except Exception:
+ pass
+ name = account.get("username", "admin")
+ game_db.log_admin_action(name, "dll_upload",
+ f"Uploaded DLL for branch {BRANCHS[branch_id]}: {new_filename}",
+ request.headers.get("X-Forwarded-For", request.remote_addr or ""))
+ try:
+ from core.discord import send_admin
+ send_admin(title="DLL Uploaded", color=0xE67E22,
+ fields=[{"name": "Branch", "value": BRANCHS[branch_id], "inline": True},
+ {"name": "By", "value": name, "inline": True},
+ {"name": "Size", "value": f"{len(data):,} bytes", "inline": True},
+ {"name": "SHA512", "value": f"`{sha512[:32]}...`", "inline": False}])
+ except Exception:
+ pass
+ success = f"Uploaded to {BRANCHS[branch_id]} ({len(data):,} bytes)."
+
+ return self.render(
+ "admin/kittyrecMod.html",
+ account=account,
+ scopes=scopes,
+ branchs=BRANCHS,
+ dll_data=dll_data,
+ error=error,
+ success=success,
+ SCOPE_ADMIN=SCOPE_ADMIN,
+ )
+
+
+_PRIORITY_LABELS = {0: "Low", 1: "Medium", 2: "High", 3: "Critical"}
+_PRIORITY_COLORS = {0: "secondary", 1: "info", 2: "warning", 3: "danger"}
+_STATUS_COLORS = {"open": "primary", "in_progress": "warning", "done": "success", "closed": "secondary",
+ "reported": "primary", "confirmed": "info", "investigating": "warning", "resolved": "success", "wontfix": "secondary"}
+_SEVERITY_COLORS = {"low": "secondary", "medium": "info", "high": "warning", "critical": "danger"}
+
+
+class TodoView(_AuthMixin, ModelView):
+ can_create = True
+ can_edit = True
+ can_delete = True
+ column_list = ["id", "title", "priority", "status", "assigned_to", "created_by", "created_at", "completed_at"]
+ column_searchable_list = ["title", "description", "assigned_to", "created_by"]
+ column_filters = ["status", "priority", "assigned_to"]
+ column_default_sort = [("status", False), ("priority", True)]
+ column_editable_list = ["assigned_to"]
+ page_size = 50
+ form_excluded_columns = ["created_at", "completed_at"]
+ column_labels = {
+ "assigned_to": "Assigned To",
+ "created_by": "Created By",
+ "created_at": "Created",
+ "completed_at": "Completed",
+ }
+ form_choices = {
+ "status": [("open", "Open"), ("in_progress", "In Progress"), ("done", "Done"), ("closed", "Closed")],
+ "priority": [(0, "Low"), (1, "Medium"), (2, "High"), (3, "Critical")],
+ }
+ column_formatters = {
+ "priority": lambda v, c, m, p: Markup(f'{_PRIORITY_LABELS.get(m.priority, "?")}'),
+ "status": lambda v, c, m, p: Markup(f'{m.status.replace("_", " ").title()}'),
+ "title": lambda v, c, m, p: Markup(f'{m.title}' + (f'
{m.description[:80]}...' if m.description and len(m.description) > 80 else (f'
{m.description}' if m.description else ''))),
+ }
+
+ def on_model_change(self, form, model, is_created):
+ if is_created:
+ import datetime
+ account, _ = get_admin_account()
+ model.created_at = datetime.datetime.utcnow().strftime("%Y-%m-%d %H:%M:%S")
+ model.created_by = account.get("username", "admin") if account else "admin"
+ if model.status == "done" and not model.completed_at:
+ import datetime
+ model.completed_at = datetime.datetime.utcnow().strftime("%Y-%m-%d %H:%M:%S")
+ elif model.status != "done":
+ model.completed_at = None
+
+ @action("mark_done", "Mark Done", "Mark selected todos as done?")
+ def action_mark_done(self, ids):
+ import datetime
+ now = datetime.datetime.utcnow().strftime("%Y-%m-%d %H:%M:%S")
+ for id in ids:
+ todo = sql_db.session.query(AdminTodo).get(int(id))
+ if todo:
+ todo.status = "done"
+ todo.completed_at = now
+ sql_db.session.commit()
+ flash(f"Marked {len(ids)} todo(s) as done.", "success")
+
+ @action("mark_open", "Reopen", "Reopen selected todos?")
+ def action_mark_open(self, ids):
+ for id in ids:
+ todo = sql_db.session.query(AdminTodo).get(int(id))
+ if todo:
+ todo.status = "open"
+ todo.completed_at = None
+ sql_db.session.commit()
+ flash(f"Reopened {len(ids)} todo(s).", "success")
+
+
+class IssueView(_AuthMixin, ModelView):
+ can_create = True
+ can_edit = True
+ can_delete = True
+ column_list = ["id", "title", "category", "severity", "status", "reported_by", "assigned_to", "created_at", "resolved_at"]
+ column_searchable_list = ["title", "description", "reported_by", "assigned_to"]
+ column_filters = ["status", "category", "severity", "assigned_to"]
+ column_default_sort = [("status", False), ("severity", True)]
+ column_editable_list = ["assigned_to"]
+ page_size = 50
+ form_excluded_columns = ["created_at", "resolved_at"]
+ column_labels = {
+ "reported_by": "Reported By",
+ "assigned_to": "Assigned To",
+ "created_at": "Created",
+ "resolved_at": "Resolved",
+ }
+ form_choices = {
+ "status": [("open", "Open"), ("confirmed", "Confirmed"), ("investigating", "Investigating"), ("resolved", "Resolved"), ("wontfix", "Won't Fix"), ("closed", "Closed")],
+ "category": [("bug", "Bug"), ("crash", "Crash"), ("exploit", "Exploit"), ("performance", "Performance"), ("feature", "Feature Request"), ("other", "Other")],
+ "severity": [("low", "Low"), ("medium", "Medium"), ("high", "High"), ("critical", "Critical")],
+ }
+ column_formatters = {
+ "severity": lambda v, c, m, p: Markup(f'{m.severity.title()}'),
+ "status": lambda v, c, m, p: Markup(f'{m.status.replace("_", " ").title()}'),
+ "category": lambda v, c, m, p: Markup(f'{m.category.title()}'),
+ "title": lambda v, c, m, p: Markup(f'{m.title}' + (f'
{m.description[:80]}...' if m.description and len(m.description) > 80 else (f'
{m.description}' if m.description else ''))),
+ }
+
+ def on_model_change(self, form, model, is_created):
+ if is_created:
+ import datetime
+ account, _ = get_admin_account()
+ model.created_at = datetime.datetime.utcnow().strftime("%Y-%m-%d %H:%M:%S")
+ model.reported_by = model.reported_by or (account.get("username", "admin") if account else "admin")
+ if model.status in ("resolved", "closed", "wontfix") and not model.resolved_at:
+ import datetime
+ model.resolved_at = datetime.datetime.utcnow().strftime("%Y-%m-%d %H:%M:%S")
+ elif model.status not in ("resolved", "closed", "wontfix"):
+ model.resolved_at = None
+
+ @action("resolve", "Resolve", "Resolve selected issues?")
+ def action_resolve(self, ids):
+ import datetime
+ now = datetime.datetime.utcnow().strftime("%Y-%m-%d %H:%M:%S")
+ for id in ids:
+ issue = sql_db.session.query(AdminIssue).get(int(id))
+ if issue:
+ issue.status = "resolved"
+ issue.resolved_at = now
+ sql_db.session.commit()
+ flash(f"Resolved {len(ids)} issue(s).", "success")
+
+ @action("mark_critical", "Mark Critical")
+ def action_mark_critical(self, ids):
+ for id in ids:
+ issue = sql_db.session.query(AdminIssue).get(int(id))
+ if issue:
+ issue.severity = "critical"
+ sql_db.session.commit()
+ flash(f"Marked {len(ids)} issue(s) as critical.", "success")
+
+
+class AnalyticsView(_AuthMixin, BaseView):
+ @expose("/")
+ def index(self):
+ import json as _json
+
+ account, scopes = get_admin_account()
+ if not account or not has_any_admin_scope(scopes):
+ return redirect(make_login_redirect())
+
+ stats = game_db.get_amplitude_stats()
+ recent_events = game_db.get_amplitude_events(limit=200)
+ count_history = game_db.get_player_count_history(hours=72)
+ growth = game_db.get_growth_stats()
+
+ def _to_dict(rows):
+ return {r["d"]: r["c"] for r in rows}
+
+ def _all_dates(*dicts):
+ from datetime import date, timedelta
+ all_d = set()
+ for d in dicts:
+ all_d.update(d.keys())
+ if not all_d:
+ return []
+ lo = min(all_d)
+ hi = max(all_d)
+ try:
+ cur = date.fromisoformat(lo)
+ end = date.fromisoformat(hi)
+ out = []
+ while cur <= end:
+ out.append(str(cur))
+ cur += timedelta(days=1)
+ return out
+ except Exception:
+ return sorted(all_d)
+
+ def _polyline(data_dict, dates, W, H, cumulative=False):
+ if not dates:
+ return ""
+ if cumulative:
+ vals = []
+ run = 0
+ for d in dates:
+ run += data_dict.get(d, 0)
+ vals.append(run)
+ else:
+ vals = [data_dict.get(d, 0) for d in dates]
+ max_v = max(vals) if vals else 1
+ if max_v == 0:
+ max_v = 1
+ n = len(dates)
+ pts = []
+ for i, v in enumerate(vals):
+ x = round(i / max(n - 1, 1) * W, 1)
+ y = round(H - v / max_v * H, 1)
+ pts.append(f"{x},{y}")
+ return " ".join(pts)
+
+ SVG_W, SVG_H = 800, 80
+
+ reg_dict = _to_dict(growth["reg_by_day"])
+ login_dict = _to_dict(growth["daily_logins"])
+ visit_dict = _to_dict(growth["room_visits_by_day"])
+ chat_dict = _to_dict(growth["chat_by_day"])
+ photo_dict = _to_dict(growth["photos_by_day"])
+ gift_dict = _to_dict(growth["gifts_by_day"])
+ unlock_dict= _to_dict(growth["unlocked_by_day"])
+ admin_dict = _to_dict(growth["admin_by_day"])
+
+ all_activity_dates = _all_dates(login_dict, visit_dict, chat_dict, photo_dict)
+ all_dates = _all_dates(reg_dict, login_dict, visit_dict, chat_dict, photo_dict, gift_dict)
+
+ growth_charts = {
+ "cum_reg": _polyline(reg_dict, all_dates, SVG_W, SVG_H, cumulative=True),
+ "daily_reg": _polyline(reg_dict, all_dates, SVG_W, SVG_H),
+ "logins": _polyline(login_dict, all_activity_dates, SVG_W, SVG_H),
+ "visits": _polyline(visit_dict, all_activity_dates, SVG_W, SVG_H),
+ "chat": _polyline(chat_dict, all_activity_dates, SVG_W, SVG_H),
+ "photos": _polyline(photo_dict, all_activity_dates, SVG_W, SVG_H),
+ "gifts": _polyline(gift_dict, all_dates, SVG_W, SVG_H),
+ "unlocked": _polyline(unlock_dict,all_dates, SVG_W, SVG_H),
+ "admin": _polyline(admin_dict, _all_dates(admin_dict), SVG_W, SVG_H),
+ }
+
+ ban_by_day_bans = {}
+ ban_by_day_unbans = {}
+ for row in growth["bans_by_day"]:
+ d = row["d"]
+ if row["action"] == "ban":
+ ban_by_day_bans[d] = row["c"]
+ else:
+ ban_by_day_unbans[d] = row["c"]
+ ban_dates = _all_dates(ban_by_day_bans, ban_by_day_unbans)
+ growth_charts["bans"] = _polyline(ban_by_day_bans, ban_dates, SVG_W, SVG_H)
+ growth_charts["unbans"] = _polyline(ban_by_day_unbans, ban_dates, SVG_W, SVG_H)
+
+ activity_series_maxes = {
+ "Logins": max(login_dict.values()) if login_dict else 0,
+ "Visits": max(visit_dict.values()) if visit_dict else 0,
+ "Chat": max(chat_dict.values()) if chat_dict else 0,
+ "Photos": max(photo_dict.values()) if photo_dict else 0,
+ }
+
+ date_labels = {
+ "all_first": all_dates[0] if all_dates else "",
+ "all_last": all_dates[-1] if all_dates else "",
+ "act_first": all_activity_dates[0] if all_activity_dates else "",
+ "act_last": all_activity_dates[-1] if all_activity_dates else "",
+ "ban_first": ban_dates[0] if ban_dates else "",
+ "ban_last": ban_dates[-1] if ban_dates else "",
+ }
+
+ def parse_props(row, key="event_props"):
+ try:
+ v = row.get(key) if isinstance(row, dict) else row[key]
+ return _json.loads(v) if isinstance(v, str) else (v or {})
+ except Exception:
+ return {}
+
+ def _safe_uid(v):
+ try:
+ return int(v) if v and str(v).lstrip('-').isdigit() else None
+ except (ValueError, TypeError):
+ return None
+
+ all_user_ids = set()
+ for u in stats["by_user"]:
+ uid = _safe_uid(u["user_id"])
+ if uid:
+ all_user_ids.add(uid)
+ for row in stats["all_activity"] + stats["purchase_rows"] + stats["crash_rows"] + stats["social_rows"] + stats["network_rows"] + stats["objective_rows"] + stats["load_rows"] + stats["levelup_rows"] + stats["photon_rows"]:
+ uid = _safe_uid(row.get("user_id"))
+ if uid:
+ all_user_ids.add(uid)
+ for ev in recent_events:
+ uid = _safe_uid(ev.get("user_id"))
+ if uid:
+ all_user_ids.add(uid)
+
+ profiles_map = game_db.get_profiles_batch(list(all_user_ids)) if all_user_ids else {}
+ user_names = {uid: (p["Username"] if p else f"#{uid}") for uid, p in profiles_map.items()}
+
+ activity_rows = []
+ act_buckets = {}
+ for row in stats["all_activity"]:
+ p = parse_props(row)
+ name = p.get("activityName", "unknown")
+ entry = {
+ "user_id": row["user_id"],
+ "activity": name,
+ "total_time": float(p.get("total_time") or 0),
+ "avg_fps": float(p.get("avg_fps") or 0),
+ "min_fps": float(p.get("min_fps") or 0),
+ "max_fps": float(p.get("max_fps") or 0),
+ "stdev_fps": float(p.get("stdev_fps") or 0),
+ "avg_ping": float(p.get("avg_ping") or 0),
+ "min_ping": float(p.get("min_ping") or 0),
+ "max_ping": float(p.get("max_ping") or 0),
+ "stdev_ping": float(p.get("stdev_ping") or 0),
+ "dropped_frames_perc": float(p.get("dropped_frames_perc") or 0),
+ "rw_dropped_perc": float(p.get("rw_dropped_frames_perc") or 0),
+ "rw_dropped_1to2p_perc": float(p.get("rw_dropped_frames_1to2p_perc") or 0),
+ "avg_sl": float(p.get("avg_sl") or 0),
+ "load_time": float(p.get("loadTime") or 0),
+ "load_source": p.get("load_source", ""),
+ "is_sandbox": bool(p.get("is_sandbox", False)),
+ "tt_public": float(p.get("tt_Public") or 0),
+ "tt_private": float(p.get("tt_Private") or 0),
+ "tt_dorm": float(p.get("tt_Dorm") or 0),
+ "c_received_gift": int(p.get("c_received_gift") or 0),
+ "created_at": row["created_at"],
+ }
+ activity_rows.append(entry)
+ if name not in act_buckets:
+ act_buckets[name] = {"sessions": 0, "total_time": 0, "fps": [], "ping": [], "stdev_fps": [], "stdev_ping": [], "rw_drop": [], "sl": [], "load_times": [], "gifts": 0}
+ b = act_buckets[name]
+ b["sessions"] += 1
+ b["total_time"] += entry["total_time"]
+ if entry["avg_fps"]: b["fps"].append(entry["avg_fps"])
+ if entry["avg_ping"]: b["ping"].append(entry["avg_ping"])
+ if entry["stdev_fps"]: b["stdev_fps"].append(entry["stdev_fps"])
+ if entry["stdev_ping"]: b["stdev_ping"].append(entry["stdev_ping"])
+ if entry["rw_dropped_perc"] is not None: b["rw_drop"].append(entry["rw_dropped_perc"])
+ if entry["avg_sl"]: b["sl"].append(entry["avg_sl"])
+ if entry["load_time"]: b["load_times"].append(entry["load_time"])
+ b["gifts"] += entry["c_received_gift"]
+
+ def avg(lst): return round(sum(lst) / len(lst), 2) if lst else 0
+
+ activity_summary = {}
+ for name, b in act_buckets.items():
+ activity_summary[name] = {
+ "sessions": b["sessions"],
+ "total_time": b["total_time"],
+ "avg_fps": avg(b["fps"]),
+ "avg_ping": avg(b["ping"]),
+ "avg_stdev_fps": avg(b["stdev_fps"]),
+ "avg_stdev_ping": avg(b["stdev_ping"]),
+ "avg_rw_drop": avg(b["rw_drop"]),
+ "avg_sl": avg(b["sl"]),
+ "avg_load_time": avg(b["load_times"]),
+ "total_gifts": b["gifts"],
+ }
+
+ PHOTON_REGIONS = ["eu", "us", "usw", "cae", "asia", "jp", "au", "sa", "in", "ru", "rue", "kr"]
+ region_buckets = {r: [] for r in PHOTON_REGIONS}
+ for row in stats["photon_rows"]:
+ p = parse_props(row)
+ for r in PHOTON_REGIONS:
+ v = p.get(r)
+ if v is not None:
+ try:
+ region_buckets[r].append(int(v))
+ except (ValueError, TypeError):
+ pass
+
+ photon_summary = {}
+ for r in PHOTON_REGIONS:
+ vals = region_buckets[r]
+ if vals:
+ svals = sorted(vals)
+ p95_idx = max(0, int(len(svals) * 0.95) - 1)
+ photon_summary[r] = {
+ "avg": avg(vals),
+ "min": min(vals),
+ "max": max(vals),
+ "p95": svals[p95_idx],
+ "count": len(vals),
+ }
+
+ purchases = []
+ item_buckets = {}
+ daily_spend = {}
+ type_spend = {}
+ storefront_counts = {}
+ for row in stats["purchase_rows"]:
+ p = parse_props(row)
+ name = p.get("item_name", "Unknown")
+ cost = int(p.get("item_cost") or 0)
+ itype = p.get("item_type", "Unknown")
+ sf = p.get("storefront", "Unknown")
+ day = (row.get("created_at") or "")[:10]
+ purchases.append({"user_id": row["user_id"], "item_name": name, "cost": cost,
+ "item_type": itype, "storefront": sf,
+ "initial_bal": p.get("initial_bal", 0),
+ "new_bal": p.get("new_bal", 0),
+ "created_at": row.get("created_at", "")})
+ if name not in item_buckets:
+ item_buckets[name] = {"count": 0, "total_cost": 0, "item_type": itype}
+ item_buckets[name]["count"] += 1
+ item_buckets[name]["total_cost"] += cost
+ daily_spend[day] = daily_spend.get(day, 0) + cost
+ type_spend[itype] = type_spend.get(itype, 0) + 1
+ storefront_counts[sf] = storefront_counts.get(sf, 0) + 1
+
+ top_items = sorted(item_buckets.items(), key=lambda x: x[1]["count"], reverse=True)
+ total_tokens_spent = sum(p["cost"] for p in purchases)
+
+ crashes = []
+ crash_patterns = {}
+ for row in stats["crash_rows"]:
+ p = parse_props(row)
+ err = p.get("error", "Unknown")[:120]
+ stack = p.get("stackTrace", "")
+ crashes.append({"user_id": row["user_id"], "error": err, "stack": stack, "created_at": row.get("created_at", "")})
+ crash_patterns[err] = crash_patterns.get(err, 0) + 1
+
+ social_counts = {}
+ invite_funnel = {"sent": 0, "received": 0, "accepted": 0}
+ for row in stats["social_rows"]:
+ et = row["event_type"]
+ social_counts[et] = social_counts.get(et, 0) + 1
+ if et == "sent_game_invite": invite_funnel["sent"] += 1
+ elif et == "received_GameInvite": invite_funnel["received"] += 1
+ elif et == "accepted_game_invite": invite_funnel["accepted"] += 1
+
+ network_events = []
+ conn_failures = {}
+ master_switches = []
+ for row in stats["network_rows"]:
+ p = parse_props(row)
+ et = row["event_type"]
+ network_events.append({"event_type": et, "user_id": row["user_id"], "props": p, "created_at": row.get("created_at", "")})
+ if et == "connection_failure":
+ cause = p.get("cause", "Unknown")
+ conn_failures[cause] = conn_failures.get(cause, 0) + 1
+ elif et == "network_masterSwitched":
+ master_switches.append({"user_id": row["user_id"], "activity": p.get("activityName", ""), "new_ping": p.get("newPing"), "old_ping": p.get("oldPing"), "created_at": row.get("created_at", "")})
+
+ load_scene_stats = {}
+ for row in stats["load_rows"]:
+ p = parse_props(row)
+ scene = row["event_type"].replace("_load", "").replace("_additive_load", "")
+ if scene not in load_scene_stats:
+ load_scene_stats[scene] = {"count": 0, "players": set(), "sources": {}}
+ load_scene_stats[scene]["count"] += 1
+ uid = row.get("user_id")
+ if uid: load_scene_stats[scene]["players"].add(uid)
+ src = p.get("source", p.get("prev", ""))
+ if src: load_scene_stats[scene]["sources"][src] = load_scene_stats[scene]["sources"].get(src, 0) + 1
+ for k in load_scene_stats:
+ load_scene_stats[k]["players"] = len(load_scene_stats[k]["players"])
+
+ levelup_data = []
+ for row in stats["levelup_rows"]:
+ p = parse_props(row)
+ levelup_data.append({
+ "user_id": row["user_id"],
+ "activity": p.get("activityName", "—"),
+ "created_at": row.get("created_at", ""),
+ })
+
+ objective_data = []
+ for row in stats["objective_rows"]:
+ p = parse_props(row)
+ objective_data.append({
+ "user_id": row["user_id"],
+ "type": p.get("type", "—"),
+ "score": p.get("requiredScore", "—"),
+ "level": p.get("Level", "—"),
+ "created_at": row.get("created_at", ""),
+ })
+
+ gift_open_total = sum(g["c"] for g in stats["gift_stats"])
+ gift_open_consumed = next((g["c"] for g in stats["gift_stats"] if g["consumed"]), 0)
+ gift_open_rate = round(gift_open_consumed / gift_open_total * 100, 1) if gift_open_total else 0
+
+ events_by_day = {r["d"]: r["c"] for r in stats["events_by_day"]}
+ events_by_hour = {r["h"]: r["c"] for r in stats["events_by_hour"]}
+ sessions_by_day = {r["d"]: r["c"] for r in stats["sessions_by_day"]}
+
+ total_playtime_secs = sum(a["total_time"] for a in activity_rows)
+
+ for ev in recent_events:
+ ev["_props"] = parse_props(ev)
+
+ return self.render(
+ "admin/analytics_view.html",
+ stats=stats,
+ recent_events=recent_events,
+ activity_rows=activity_rows,
+ activity_summary=activity_summary,
+ photon_summary=photon_summary,
+ purchases=purchases,
+ top_items=top_items,
+ total_tokens_spent=total_tokens_spent,
+ daily_spend=daily_spend,
+ type_spend=type_spend,
+ storefront_counts=storefront_counts,
+ crashes=crashes,
+ crash_patterns=crash_patterns,
+ social_counts=social_counts,
+ invite_funnel=invite_funnel,
+ network_events=network_events,
+ conn_failures=conn_failures,
+ master_switches=master_switches,
+ load_scene_stats=load_scene_stats,
+ gift_open_rate=gift_open_rate,
+ gift_open_consumed=gift_open_consumed,
+ gift_open_total=gift_open_total,
+ events_by_day=events_by_day,
+ events_by_hour=events_by_hour,
+ sessions_by_day=sessions_by_day,
+ total_playtime_secs=total_playtime_secs,
+ levelup_data=levelup_data,
+ objective_data=objective_data,
+ growth=growth,
+ growth_charts=growth_charts,
+ activity_series_maxes=activity_series_maxes,
+ date_labels=date_labels,
+ count_history=count_history,
+ user_names=user_names,
+ account=account,
+ scopes=scopes,
+ SCOPE_ADMIN=SCOPE_ADMIN,
+ )
+
+
+class UGCItemsView(_AuthMixin, BaseView):
+ _DATA_PATH = None
+
+ def _items_path(self):
+ import os as _os
+ return _os.path.join(_os.path.dirname(_os.path.dirname(__file__)), "data", "ugc_outfit_items.json")
+
+ def _load(self):
+ import json as _json
+ try:
+ with open(self._items_path()) as f:
+ return _json.load(f)
+ except Exception:
+ return []
+
+ def _save(self, items):
+ import json as _json
+ with open(self._items_path(), "w") as f:
+ _json.dump(items, f, indent=2)
+
+ @expose("/", methods=["GET", "POST"])
+ def index(self):
+ import os as _os, uuid as _uuid
+ account, scopes = get_admin_account()
+ if not account or not has_any_admin_scope(scopes):
+ return redirect(make_login_redirect())
+
+ _MAX_BYTES = 10 * 1024 * 1024
+ error = None
+ success = None
+
+ if request.method == "POST" and SCOPE_ADMIN in scopes:
+ action_type = request.form.get("action_type", "add")
+ items = self._load()
+
+ if action_type == "add":
+ friendly_name = request.form.get("friendly_name", "").strip()[:128]
+ use_cdn = request.form.get("use_cdn") == "1"
+ version = max(0, int(request.form.get("version", 0) or 0))
+
+ if not friendly_name:
+ error = "Friendly name is required."
+ elif use_cdn:
+ f_bundle = request.files.get("assetbundle_file")
+ f_manifest = request.files.get("manifest_file")
+ if not f_bundle or not f_manifest:
+ error = "Both files are required for CDN upload."
+ else:
+ bundle_data = f_bundle.read(_MAX_BYTES + 1)
+ manifest_data = f_manifest.read(_MAX_BYTES + 1)
+ if len(bundle_data) > _MAX_BYTES or len(manifest_data) > _MAX_BYTES:
+ error = "Files too large (max 10MB each)."
+ else:
+ random_stem = _uuid.uuid4().hex
+ bundle_cdn_name = f"cdn_ugc_{random_stem}.assetbundle"
+ manifest_cdn_name = f"cdn_ugc_{random_stem}.manifest"
+ game_db.save_named_image(bundle_cdn_name, -1, bundle_data, room_name=friendly_name)
+ game_db.save_named_image(manifest_cdn_name, -1, manifest_data, room_name=friendly_name)
+ item_id = str(_uuid.uuid4())
+ items.append({
+ "id": item_id,
+ "friendly_name": friendly_name,
+ "assetbundle_name": bundle_cdn_name,
+ "manifest_name": manifest_cdn_name,
+ "version": version,
+ })
+ self._save(items)
+ admin_name = account.get("username", "admin")
+ game_db.log_admin_action(admin_name, "add_ugc_outfit_item",
+ f"Added UGC outfit item '{friendly_name}' (bundle={bundle_cdn_name})",
+ request.headers.get("X-Forwarded-For", request.remote_addr or ""))
+ success = f"Added '{friendly_name}' (CDN)."
+ else:
+ bundle_path = request.form.get("bundle_url", "").strip()
+ manifest_path = request.form.get("manifest_url", "").strip()
+ if not bundle_path or not manifest_path:
+ error = "Both AssetbundleName and ManifestName paths are required."
+ else:
+ item_id = str(_uuid.uuid4())
+ items.append({
+ "id": item_id,
+ "friendly_name": friendly_name,
+ "assetbundle_name": bundle_path,
+ "manifest_name": manifest_path,
+ "version": version,
+ })
+ self._save(items)
+ admin_name = account.get("username", "admin")
+ game_db.log_admin_action(admin_name, "add_ugc_outfit_item",
+ f"Added UGC outfit item '{friendly_name}' (direct, bundle={bundle_path})",
+ request.headers.get("X-Forwarded-For", request.remote_addr or ""))
+ success = f"Added '{friendly_name}' (direct URL)."
+
+ elif action_type == "edit":
+ item_id = request.form.get("item_id", "")
+ friendly_name = request.form.get("friendly_name", "").strip()[:128]
+ bundle_path = request.form.get("bundle_url", "").strip()
+ manifest_path = request.form.get("manifest_url", "").strip()
+ version = max(0, int(request.form.get("version", 0) or 0))
+ target = next((i for i in items if i.get("id") == item_id), None)
+ if not target:
+ error = "Item not found."
+ elif not friendly_name or not bundle_path or not manifest_path:
+ error = "All fields required."
+ else:
+ target["friendly_name"] = friendly_name
+ target["assetbundle_name"] = bundle_path
+ target["manifest_name"] = manifest_path
+ target["version"] = version
+ self._save(items)
+ admin_name = account.get("username", "admin")
+ game_db.log_admin_action(admin_name, "edit_ugc_outfit_item",
+ f"Edited UGC outfit item '{friendly_name}' (id={item_id})",
+ request.headers.get("X-Forwarded-For", request.remote_addr or ""))
+ success = f"Saved '{friendly_name}'."
+
+ elif action_type == "delete":
+ item_id = request.form.get("item_id", "")
+ before = len(items)
+ items = [i for i in items if i.get("id") != item_id]
+ if len(items) < before:
+ self._save(items)
+ admin_name = account.get("username", "admin")
+ game_db.log_admin_action(admin_name, "delete_ugc_outfit_item",
+ f"Deleted UGC outfit item id={item_id}",
+ request.headers.get("X-Forwarded-For", request.remote_addr or ""))
+ success = "Item deleted."
+ else:
+ error = "Item not found."
+
+ items = self._load()
+ return self.render(
+ "admin/ugc_items_view.html",
+ items=items,
+ error=error,
+ success=success,
+ account=account,
+ scopes=scopes,
+ SCOPE_ADMIN=SCOPE_ADMIN,
+ )
+
+
+class MusicView(_AuthMixin, BaseView):
+ _MAX_BYTES = 100 * 1024 * 1024
+
+ @expose("/", methods=["GET", "POST"])
+ def index(self):
+ import os as _os, re as _re
+ account, scopes = get_admin_account()
+ if not account or not has_any_admin_scope(scopes):
+ return redirect(make_login_redirect())
+
+ from routes.music import MUSIC_DIR, _CONVERT_EXTS
+ MUSIC_DIR.mkdir(exist_ok=True)
+
+ error = None
+ success = None
+ _ALLOWED_EXTS = _CONVERT_EXTS | {".wav"}
+
+ if request.method == "POST" and SCOPE_ADMIN in scopes:
+ action_type = request.form.get("action_type", "upload")
+ _ip = request.headers.get("X-Forwarded-For", request.remote_addr or "")
+ admin_name = account.get("username", "admin")
+
+ if action_type == "upload":
+ f = request.files.get("music_file")
+ if not f or not f.filename:
+ error = "No file selected."
+ else:
+ ext = _os.path.splitext(f.filename)[1].lower()
+ if ext not in _ALLOWED_EXTS:
+ error = f"Unsupported format. Allowed: {', '.join(sorted(_ALLOWED_EXTS))}"
+ else:
+ data = f.read(self._MAX_BYTES + 1)
+ if len(data) > self._MAX_BYTES:
+ error = "File too large (max 100 MB)."
+ else:
+ safe_name = _re.sub(r"[^\w\s\-.]", "", f.filename).strip()
+ if not safe_name:
+ safe_name = "track" + ext
+ dest = MUSIC_DIR / safe_name
+ with open(dest, "wb") as out:
+ out.write(data)
+ game_db.log_admin_action(admin_name, "music_upload",
+ f"Uploaded track '{safe_name}' ({len(data):,} bytes)", _ip)
+ success = f"Uploaded '{safe_name}' ({len(data) // 1024:,} KB)."
+
+ elif action_type == "delete":
+ filename = request.form.get("filename", "").strip()
+ if filename:
+ target = (MUSIC_DIR / filename).resolve()
+ music_root = str(MUSIC_DIR.resolve())
+ if not str(target).startswith(music_root + _os.sep):
+ error = "Invalid filename."
+ elif not target.exists() or not target.is_file():
+ error = "File not found."
+ else:
+ target.unlink()
+ wav_sibling = target.with_suffix(".wav")
+ if target.suffix.lower() != ".wav" and wav_sibling.exists():
+ wav_sibling.unlink()
+ game_db.log_admin_action(admin_name, "music_delete",
+ f"Deleted track '{filename}'", _ip)
+ success = f"Deleted '{filename}'."
+
+ elif action_type == "rename":
+ old_name = request.form.get("old_name", "").strip()
+ new_name = request.form.get("new_name", "").strip()
+ if old_name and new_name:
+ safe_new = _re.sub(r"[^\w\s\-.]", "", new_name).strip()
+ src = (MUSIC_DIR / old_name).resolve()
+ dst = (MUSIC_DIR / safe_new).resolve()
+ music_root = str(MUSIC_DIR.resolve())
+ if not str(src).startswith(music_root + _os.sep) or not str(dst).startswith(music_root + _os.sep):
+ error = "Invalid filename."
+ elif not src.exists():
+ error = "Source file not found."
+ elif dst.exists():
+ error = f"'{safe_new}' already exists."
+ else:
+ src.rename(dst)
+ game_db.log_admin_action(admin_name, "music_rename",
+ f"Renamed track '{old_name}' → '{safe_new}'", _ip)
+ success = f"Renamed to '{safe_new}'."
+
+ tracks = []
+ for f in sorted(MUSIC_DIR.iterdir()):
+ if f.is_file() and not f.name.startswith("."):
+ tracks.append({
+ "name": f.name,
+ "ext": f.suffix.lower(),
+ "size_kb": f.stat().st_size // 1024,
+ })
+
+ return self.render(
+ "admin/music_view.html",
+ tracks=tracks,
+ error=error,
+ success=success,
+ account=account,
+ scopes=scopes,
+ SCOPE_ADMIN=SCOPE_ADMIN,
+ )
+
+
+def create_admin(app):
+ from flask_admin.theme import Bootstrap4Theme
+ admin = Admin(
+ app,
+ name="KittyRec Admin",
+ index_view=HomeView(name="Dashboard", url="/admin", endpoint="admin"),
+ theme=Bootstrap4Theme(base_template="admin/custom_base.html"),
+ )
+ admin.add_view(ProfileView(Profile, sql_db.session, name="Players", endpoint="admin_players", category="Players"))
+ admin.add_view(GiftView(Gift, sql_db.session, name="Gifts", endpoint="admin_gifts", category="Players"))
+ admin.add_view(BanLogView(BanLog, sql_db.session, name="Ban Log", endpoint="admin_bans", category="Players"))
+
+ admin.add_view(RoomsManageView(name="Rooms", endpoint="admin_rooms_manage", url="/admin/live/rooms", category="Game"))
+ admin.add_view(SessionsView(name="Live Sessions", endpoint="admin_sessions", url="/admin/live/sessions", category="Game"))
+ admin.add_view(StoreView(name="Store", endpoint="admin_store", url="/admin/live/store", category="Game"))
+ admin.add_view(EventsView(name="Events", endpoint="admin_events", url="/admin/live/events", category="Game"))
+
+ admin.add_view(TexturesView(name="Game Assets", endpoint="admin_textures", url="/admin/live/textures", category="Content"))
+ admin.add_view(SwatchesView(name="Swatches", endpoint="admin_swatches", url="/admin/live/swatches", category="Content"))
+ admin.add_view(AvatarItemsView(name="Avatar Items", endpoint="admin_avatar_items", url="/admin/live/avatar_items", category="Content"))
+ admin.add_view(UGCItemsView(name="UGC Avatar", endpoint="admin_ugc_items", url="/admin/live/ugc_items", category="Content"))
+ admin.add_view(MusicView(name="Music", endpoint="admin_music", url="/admin/live/music", category="Content"))
+ admin.add_view(CdnView(name="CDN", endpoint="admin_cdn", url="/admin/live/cdn", category="Content"))
+ admin.add_view(DownloadsView(name="Downloads", endpoint="admin_downloads", url="/admin/live/downloads", category="Content"))
+ admin.add_view(DllArchiveView(name="DLL Archive", endpoint="admin_dll_archive", url="/admin/live/dll_archive", category="Content"))
+ admin.add_view(kittyrecModView(name="KittyRec Mod", endpoint="admin_kittyrec_mod", url="/admin/kittyrec/mod", category="Content"))
+
+ admin.add_view(TodoView(AdminTodo, sql_db.session, name="Todos", endpoint="admin_todos", category="Tracking"))
+ admin.add_view(IssueView(AdminIssue, sql_db.session, name="Issues", endpoint="admin_issues", category="Tracking"))
+
+ admin.add_view(AnalyticsView(name="Analytics", endpoint="admin_analytics", url="/admin/analytics", category="System"))
+ admin.add_view(ConsoleView(name="Console", endpoint="admin_console", url="/admin/live/console", category="System"))
+ return admin
diff --git a/core/admin_ws.py b/core/admin_ws.py
new file mode 100644
index 0000000..55422ec
--- /dev/null
+++ b/core/admin_ws.py
@@ -0,0 +1,36 @@
+import json
+import threading
+
+_conns: set = set()
+_lock = threading.Lock()
+
+
+def register(ws) -> None:
+ with _lock:
+ _conns.add(ws)
+
+
+def unregister(ws) -> None:
+ with _lock:
+ _conns.discard(ws)
+
+
+def connected_count() -> int:
+ with _lock:
+ return len(_conns)
+
+
+def push(msg: dict) -> None:
+ data = json.dumps(msg)
+ with _lock:
+ targets = list(_conns)
+ dead = []
+ for ws in targets:
+ try:
+ ws.send(data)
+ except Exception:
+ dead.append(ws)
+ if dead:
+ with _lock:
+ for ws in dead:
+ _conns.discard(ws)
diff --git a/core/anticheat.py b/core/anticheat.py
new file mode 100644
index 0000000..eb502b9
--- /dev/null
+++ b/core/anticheat.py
@@ -0,0 +1,206 @@
+
+import os
+import threading
+import urllib.request
+import json
+
+from core.state import db, ws_registry, session_mgr
+from core.ws_helpers import push_kick, push_presence
+from core.constants import DORM_ROOM_GUID
+from core.config import discord as _discord_cfg
+
+_WEBHOOK_URL = _discord_cfg.get("webhook_anticheat", "")
+
+_offense_counts: dict[int, int] = {}
+_active_sessions: dict[int, str] = {}
+_lock = threading.Lock()
+
+_SUSPECTS_FILE = os.path.join(os.path.dirname(__file__), "..", "tracking", "anticheat_suspects.json")
+
+def _load_suspects() -> None:
+ global _offense_counts
+ try:
+ if os.path.exists(_SUSPECTS_FILE):
+ with open(_SUSPECTS_FILE) as f:
+ data = json.load(f)
+ _offense_counts = {int(k): v for k, v in data.items()}
+ except Exception as e:
+ print(f"[AntiCheat] Failed to load suspects: {e}")
+
+def _save_suspects() -> None:
+ try:
+ with open(_SUSPECTS_FILE, "w") as f:
+ json.dump({str(k): v for k, v in _offense_counts.items()}, f)
+ except Exception as e:
+ print(f"[AntiCheat] Failed to save suspects: {e}")
+
+def get_suspects() -> list:
+ with _lock:
+ counts = dict(_offense_counts)
+ if not counts:
+ return []
+ pids = list(counts.keys())
+ profiles = db.get_profiles_batch(pids)
+ result = []
+ for pid, count in sorted(counts.items(), key=lambda x: -x[1]):
+ p = profiles.get(pid)
+ if p:
+ result.append({"id": pid, "username": p["Username"], "level": p["Level"], "offenses": count, "banned": bool(p.get("Banned"))})
+ return result
+
+_load_suspects()
+
+
+def _send_webhook(title: str, color: int, fields: list[dict]) -> None:
+ try:
+ payload = {"embeds": [{"title": title, "color": color, "fields": fields}]}
+ data = json.dumps(payload).encode()
+ req = urllib.request.Request(
+ _WEBHOOK_URL,
+ data=data,
+ headers={"Content-Type": "application/json"},
+ method="POST",
+ )
+ urllib.request.urlopen(req, timeout=5)
+ except Exception as e:
+ print(f"[AntiCheat] Webhook failed: {e}")
+
+
+def check_banned_room_join(player_id: int, activity_guid: str) -> bool:
+ """
+ Called on every room join attempt.
+ Returns True and handles enforcement if player is banned trying to join a non-dorm room.
+ """
+ if activity_guid == DORM_ROOM_GUID:
+ return False
+
+ if not db.is_banned(player_id):
+ return False
+
+ with _lock:
+ _offense_counts[player_id] = _offense_counts.get(player_id, 0) + 1
+ offense = _offense_counts[player_id]
+ _save_suspects()
+ try:
+ import core.admin_ws as awr
+ awr.push({"type": "suspects", "suspects": get_suspects()})
+ except Exception:
+ pass
+
+ profile = db.get_profile(player_id)
+ username = profile.get("Username", str(player_id)) if profile else str(player_id)
+
+ if offense == 1:
+ print(f"[AntiCheat] Banned player {player_id} ({username}) tried to join room — "
+ f"kicking to dorm (offense 1)")
+ push_kick(player_id, message="You are banned and cannot join rooms.")
+ ws_registry.unregister(player_id)
+ session_mgr.leave_session(player_id)
+ push_presence(player_id, None, online=False)
+ else:
+ print(f"[AntiCheat] Banned player {player_id} ({username}) bypassed — "
+ f"closing game (offense {offense})")
+ ws_registry.send(player_id, {"Id": 20, "Msg": {}})
+ ws_registry.unregister(player_id)
+ session_mgr.leave_session(player_id)
+ push_presence(player_id, None, online=False)
+ threading.Thread(
+ target=_send_webhook,
+ args=(
+ "Banned Player Attempted Room Join",
+ 0xFF4444,
+ [
+ {"name": "Player", "value": f"{username} (id={player_id})", "inline": True},
+ {"name": "Offense #", "value": str(offense), "inline": True},
+ {"name": "Room", "value": activity_guid, "inline": False},
+ {"name": "Action", "value": "Game force-closed (Application.Quit)", "inline": False},
+ ],
+ ),
+ daemon=True,
+ ).start()
+ try:
+ from core.discord import send_admin
+ send_admin(title="AntiCheat: Banned Room Join Attempt", color=0xFF4444,
+ fields=[{"name": "Player", "value": f"{username} (id={player_id})", "inline": True},
+ {"name": "Offense #", "value": str(offense), "inline": True},
+ {"name": "Room", "value": activity_guid[:80], "inline": False}])
+ except Exception:
+ pass
+
+ return True
+
+
+def check_dual_login(player_id: int, jti: str) -> None:
+ """
+ Called whenever a new token is issued for a player.
+ If the player already has an active WS session, fires a webhook alert.
+ """
+ if not ws_registry.send.__self__ if hasattr(ws_registry.send, '__self__') else False:
+ return
+ online = player_id in ws_registry.connected_ids()
+ if not online:
+ with _lock:
+ _active_sessions.pop(player_id, None)
+ return
+
+ with _lock:
+ prev_jti = _active_sessions.get(player_id)
+ _active_sessions[player_id] = jti
+
+ if prev_jti and prev_jti != jti:
+ profile = db.get_profile(player_id)
+ username = profile.get("Username", str(player_id)) if profile else str(player_id)
+ print(f"[AntiCheat] Dual login detected for player {player_id} ({username})")
+ threading.Thread(
+ target=_send_webhook,
+ args=(
+ "Dual Login Detected",
+ 0xFF8C00,
+ [
+ {"name": "Player", "value": f"{username} (id={player_id})", "inline": True},
+ {"name": "Status", "value": "Already online when new login occurred", "inline": False},
+ ],
+ ),
+ daemon=True,
+ ).start()
+ try:
+ from core.discord import send_admin
+ send_admin(title="AntiCheat: Dual Login", color=0xFF8C00,
+ fields=[{"name": "Player", "value": f"{username} (id={player_id})", "inline": True},
+ {"name": "Note", "value": "New login while already online", "inline": False}])
+ except Exception:
+ pass
+
+
+def on_token_issued(player_id: int, jti: str) -> None:
+ """Call this whenever a JWT is issued for a player."""
+ online = player_id in ws_registry.connected_ids()
+ if not online:
+ return
+ profile = db.get_profile(player_id)
+ username = profile.get("Username", str(player_id)) if profile else str(player_id)
+ print(f"[AntiCheat] New login while online for player {player_id} ({username})")
+ threading.Thread(
+ target=_send_webhook,
+ args=(
+ "Dual Login Detected",
+ 0xFF8C00,
+ [
+ {"name": "Player", "value": f"{username} (id={player_id})", "inline": True},
+ {"name": "Note", "value": "Player logged in from a second location while already online", "inline": False},
+ ],
+ ),
+ daemon=True,
+ ).start()
+
+
+def reset_offenses(player_id: int) -> None:
+ with _lock:
+ _offense_counts.pop(player_id, None)
+ _active_sessions.pop(player_id, None)
+ _save_suspects()
+ try:
+ import core.admin_ws as awr
+ awr.push({"type": "suspects", "suspects": get_suspects()})
+ except Exception:
+ pass