2732 lines
105 KiB
Python
2732 lines
105 KiB
Python
import json
|
|
import os
|
|
import socket
|
|
import time
|
|
import urllib.request
|
|
from functools import wraps
|
|
|
|
from flask import (
|
|
Blueprint, render_template, request, redirect, url_for,
|
|
session, jsonify, Response,
|
|
)
|
|
|
|
from core.state import db, session_mgr, ws_registry, maintenance_lock
|
|
import core.state as _state
|
|
from core.constants import DORM_ROOM_GUID
|
|
from core.ws_helpers import push_gift, push_presence
|
|
from core.limiter import limiter
|
|
from core.admin_auth import (
|
|
get_admin_account as _get_admin_account,
|
|
has_any_admin_scope as _has_any_admin_scope,
|
|
SCOPE_ADMIN, SCOPE_MOD, AUTH_LOGIN_URL, make_login_redirect,
|
|
probe_auth_server, EMERGENCY_LOGIN_URL,
|
|
EMERGENCY_PASSWORD, _EMERGENCY_SESSION_TTL,
|
|
)
|
|
from core.config import auth as _auth_cfg, base_url as _base_url, discord as _discord_cfg
|
|
from routes.avatar import _generate_gift_for_player
|
|
|
|
bp = Blueprint("portal", __name__, template_folder="../templates")
|
|
|
|
_KITTYREC_SYSTEM_ID = 23
|
|
|
|
|
|
def _now_iso():
|
|
import datetime
|
|
return datetime.datetime.now(datetime.timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
|
|
|
|
|
|
def _send_system_message(to_pid: int, text: str) -> None:
|
|
msg_id = db.send_message(_KITTYREC_SYSTEM_ID, to_pid, 30, text)
|
|
ws_registry.send(to_pid, {"Id": 2, "Msg": {
|
|
"Id": msg_id, "FromPlayerId": _KITTYREC_SYSTEM_ID,
|
|
"SentTime": _now_iso(), "Type": 30, "Data": text,
|
|
"RoomId": None, "PlayerEventId": None,
|
|
}})
|
|
|
|
|
|
def _broadcast_system_message(text: str) -> None:
|
|
for p in db.get_all_profiles_summary():
|
|
_send_system_message(p["id"], text)
|
|
|
|
|
|
def _server_host():
|
|
try:
|
|
return socket.gethostbyname(socket.gethostname())
|
|
except Exception:
|
|
return "localhost"
|
|
|
|
|
|
def require_scope(needed):
|
|
def decorator(f):
|
|
@wraps(f)
|
|
def decorated(*args, **kwargs):
|
|
account, scopes = _get_admin_account()
|
|
if not account:
|
|
if request.is_json or request.headers.get("X-Requested-With") == "XMLHttpRequest" or request.content_type and "multipart" in request.content_type:
|
|
return jsonify({"error": "Unauthorized"}), 403
|
|
if probe_auth_server():
|
|
return redirect(EMERGENCY_LOGIN_URL)
|
|
return redirect(make_login_redirect())
|
|
if not _has_any_admin_scope(scopes):
|
|
return jsonify({"error": "Unauthorized"}), 403
|
|
if needed not in scopes:
|
|
return jsonify({"error": f"Requires {needed} scope"}), 403
|
|
return f(account=account, scopes=scopes, *args, **kwargs)
|
|
return decorated
|
|
return decorator
|
|
|
|
|
|
def require_admin_api(f):
|
|
@wraps(f)
|
|
def decorated(*args, **kwargs):
|
|
account, scopes = _get_admin_account()
|
|
if not account or not _has_any_admin_scope(scopes):
|
|
return jsonify({"error": "Unauthorized"}), 403
|
|
return f(account=account, scopes=scopes, *args, **kwargs)
|
|
return decorated
|
|
|
|
|
|
def player_required(f):
|
|
@wraps(f)
|
|
def decorated(*args, **kwargs):
|
|
if not session.get("portal_pid"):
|
|
return redirect(url_for("portal.portal_login"))
|
|
return f(*args, **kwargs)
|
|
return decorated
|
|
|
|
|
|
@bp.route("/")
|
|
@limiter.limit("30 per minute")
|
|
def index():
|
|
online = len(ws_registry.connected_ids())
|
|
sessions = len(session_mgr.all_public_sessions())
|
|
total = len(db.get_all_profiles_summary())
|
|
photos = db.get_recent_photos(48)
|
|
return render_template("index.html",
|
|
online=online, sessions=sessions, total=total,
|
|
host=_server_host(), photos=photos,
|
|
)
|
|
|
|
|
|
_LOG_PATH = os.path.join(os.path.dirname(os.path.dirname(__file__)), "logs", "server.log")
|
|
_LOG_INITIAL_BYTES = 128 * 1024
|
|
|
|
|
|
@bp.route("/admin/api/console/read")
|
|
@require_admin_api
|
|
def console_read(**_kw):
|
|
pos = request.args.get("pos", type=int, default=None)
|
|
try:
|
|
with open(_LOG_PATH, "rb") as f:
|
|
f.seek(0, 2)
|
|
size = f.tell()
|
|
if pos is None:
|
|
start = max(0, size - _LOG_INITIAL_BYTES)
|
|
else:
|
|
start = pos
|
|
f.seek(start)
|
|
chunk = f.read()
|
|
text = chunk.decode("utf-8", errors="replace")
|
|
return jsonify({"text": text, "pos": size})
|
|
except FileNotFoundError:
|
|
return jsonify({"text": "", "pos": 0})
|
|
|
|
|
|
@bp.route("/admin/api/public_stats")
|
|
@require_admin_api
|
|
def public_stats(**_kw):
|
|
return jsonify({
|
|
"online": len(ws_registry.connected_ids()),
|
|
"sessions": len(session_mgr.all_public_sessions()),
|
|
})
|
|
|
|
|
|
@bp.route("/api/public/v1/status")
|
|
@limiter.limit("60 per minute")
|
|
def public_status():
|
|
return jsonify({
|
|
"online": len(ws_registry.connected_ids()),
|
|
"sessions": len(session_mgr.all_public_sessions()),
|
|
"total_players": len(db.get_all_profiles_summary()),
|
|
"maintenance": _state.maintenance_mode,
|
|
})
|
|
|
|
|
|
@bp.route("/api/public/v1/sessions")
|
|
@limiter.limit("60 per minute")
|
|
def public_sessions():
|
|
result = []
|
|
for s in session_mgr.all_public_sessions():
|
|
result.append({
|
|
"session_id": s.session_id,
|
|
"name": s.name,
|
|
"activity_level_id": s.activity_level_id,
|
|
"player_count": len(s.players),
|
|
"max_capacity": s.max_capacity,
|
|
"sandbox": s.sandbox,
|
|
})
|
|
result.sort(key=lambda x: x["player_count"], reverse=True)
|
|
return jsonify(result)
|
|
|
|
|
|
@bp.route("/api/public/v1/players")
|
|
@limiter.limit("30 per minute")
|
|
def public_players():
|
|
online_ids = ws_registry.connected_ids()
|
|
result = []
|
|
for pid in online_ids:
|
|
p = db.get_profile(pid)
|
|
if not p:
|
|
continue
|
|
sess = session_mgr.get_player_session(pid)
|
|
result.append({
|
|
"player_id": pid,
|
|
"display_name": p.get("DisplayName") or p.get("display_name") or "",
|
|
"username": p.get("Username") or p.get("username") or "",
|
|
"room_name": sess.name if sess and not sess.private else None,
|
|
"activity_level_id": sess.activity_level_id if sess else None,
|
|
})
|
|
return jsonify(result)
|
|
|
|
|
|
@bp.route("/api/public/v1/leaderboard")
|
|
@limiter.limit("60 per minute")
|
|
def public_leaderboard():
|
|
from core.state import ws_registry
|
|
online_ids = set(ws_registry.connected_ids())
|
|
conn = db._get_conn()
|
|
rows = conn.execute(
|
|
"SELECT id, username, display_name, level, xp, developer, created_at, profile_image_name "
|
|
"FROM profiles ORDER BY xp DESC LIMIT 100"
|
|
).fetchall()
|
|
return jsonify([{
|
|
"id": r["id"],
|
|
"username": r["username"],
|
|
"display_name": r["display_name"],
|
|
"level": r["level"],
|
|
"xp": r["xp"],
|
|
"developer": bool(r["developer"]),
|
|
"online": r["id"] in online_ids,
|
|
"has_image": bool(r["profile_image_name"]),
|
|
} for r in rows])
|
|
|
|
|
|
@bp.route("/api/public/v1/photos")
|
|
@limiter.limit("30 per minute")
|
|
def public_photos():
|
|
try:
|
|
limit = min(int(request.args.get("limit", 48)), 96)
|
|
offset = max(int(request.args.get("offset", 0)), 0)
|
|
pid_param = request.args.get("pid")
|
|
profile_id = int(pid_param) if pid_param and str(pid_param).isdigit() else None
|
|
except (ValueError, TypeError):
|
|
limit, offset, profile_id = 24, 0, None
|
|
photos = db.get_photos_paginated(profile_id=profile_id, limit=limit, offset=offset)
|
|
total = db.get_photo_count(profile_id=profile_id)
|
|
return jsonify({
|
|
"photos": [{
|
|
"name": p["name"],
|
|
"url": f"/alt/{p['name']}",
|
|
"uploader": p["display_name"] or p["username"] or "Unknown",
|
|
"uploader_id": p["profile_id"],
|
|
"room": p.get("room_name") or "",
|
|
"created_at": p.get("created_at") or "",
|
|
} for p in photos],
|
|
"total": total,
|
|
"offset": offset,
|
|
"limit": limit,
|
|
})
|
|
|
|
|
|
@bp.route("/api/public/v1/profile/<int:pid>")
|
|
@limiter.limit("60 per minute")
|
|
def public_profile(pid):
|
|
p = db.get_profile(pid)
|
|
if not p:
|
|
return jsonify({"error": "Not found"}), 404
|
|
return jsonify({
|
|
"id": p["Id"],
|
|
"username": p["Username"],
|
|
"display_name": p["DisplayName"],
|
|
"level": p.get("Level", 1),
|
|
"xp": p.get("XP", 0),
|
|
"bio": p.get("Bio", ""),
|
|
"developer": bool(p.get("Developer", False)),
|
|
"reputation": p.get("Reputation", 0),
|
|
"profile_image": p.get("ProfileImageName", ""),
|
|
"created_at": p.get("created_at", ""),
|
|
})
|
|
|
|
|
|
@bp.route("/api/public/v1/search")
|
|
@limiter.limit("20 per minute")
|
|
def public_search():
|
|
q = request.args.get("q", "").strip()
|
|
if not q or len(q) < 2:
|
|
return jsonify([])
|
|
results = db.search_profiles(q, limit=20)
|
|
return jsonify([{
|
|
"id": p["Id"],
|
|
"username": p["Username"],
|
|
"display_name": p["DisplayName"],
|
|
"level": p.get("Level", 1),
|
|
"xp": p.get("XP", 0),
|
|
"has_image": bool(p.get("ProfileImageName")),
|
|
} for p in results if not p.get("Banned")])
|
|
|
|
|
|
@bp.route("/api/public/v1/profile/<int:pid>/photos")
|
|
@limiter.limit("30 per minute")
|
|
def public_profile_photos(pid):
|
|
try:
|
|
limit = min(int(request.args.get("limit", 24)), 96)
|
|
offset = max(int(request.args.get("offset", 0)), 0)
|
|
except (ValueError, TypeError):
|
|
limit, offset = 24, 0
|
|
photos = db.get_photos_paginated(profile_id=pid, limit=limit, offset=offset)
|
|
total = db.get_photo_count(profile_id=pid)
|
|
return jsonify({
|
|
"photos": [{
|
|
"name": p["name"],
|
|
"url": f"/alt/{p['name']}",
|
|
"uploader": p["display_name"] or p["username"] or "Unknown",
|
|
"room": p.get("room_name") or "",
|
|
"created_at": p.get("created_at") or "",
|
|
} for p in photos],
|
|
"total": total,
|
|
"offset": offset,
|
|
"limit": limit,
|
|
})
|
|
|
|
|
|
@bp.route("/api/public/v1/activity")
|
|
@limiter.limit("60 per minute")
|
|
def public_activity():
|
|
sessions = session_mgr.all_public_sessions()
|
|
activity_map: dict[str, dict] = {}
|
|
for s in sessions:
|
|
aid = s.activity_level_id
|
|
if not aid:
|
|
continue
|
|
if aid not in activity_map:
|
|
activity_map[aid] = {
|
|
"activity_level_id": aid,
|
|
"name": s.name,
|
|
"player_count": 0,
|
|
"session_count": 0,
|
|
}
|
|
activity_map[aid]["player_count"] += len(s.players)
|
|
activity_map[aid]["session_count"] += 1
|
|
result = sorted(activity_map.values(), key=lambda x: -x["player_count"])
|
|
return jsonify(result)
|
|
|
|
|
|
@bp.route("/api/public/v1/docs")
|
|
def public_api_docs():
|
|
import os
|
|
path = os.path.join(os.path.dirname(__file__), "..", "data", "public_api.json")
|
|
with open(path, "r") as f:
|
|
return Response(f.read(), mimetype="application/json")
|
|
|
|
|
|
_BOT_SECRET = _discord_cfg.get("bot_secret", "")
|
|
|
|
|
|
def _check_bot_auth() -> bool:
|
|
if not _BOT_SECRET:
|
|
return False
|
|
import hmac
|
|
provided = request.headers.get("X-Bot-Secret", "")
|
|
return hmac.compare_digest(provided.encode("utf-8"), _BOT_SECRET.encode("utf-8"))
|
|
|
|
|
|
@bp.route("/api/internal/discord/initiate", methods=["POST"])
|
|
def discord_initiate():
|
|
if not _check_bot_auth():
|
|
return jsonify({"error": "unauthorized"}), 401
|
|
data = request.get_json(silent=True) or {}
|
|
username = (data.get("username") or "").strip()
|
|
discord_user_id = str(data.get("discord_user_id") or "").strip()
|
|
discord_username = str(data.get("discord_username") or "").strip()
|
|
if not username or not discord_user_id:
|
|
return jsonify({"error": "missing_fields"}), 400
|
|
|
|
existing_discord = db.get_discord_link_by_discord_id(discord_user_id)
|
|
if existing_discord:
|
|
return jsonify({"status": "already_linked"}), 200
|
|
|
|
profile = db.get_profile_by_username(username)
|
|
if not profile:
|
|
return jsonify({"status": "not_found"}), 200
|
|
|
|
pid = profile["Id"]
|
|
|
|
existing_profile = db.get_discord_link_by_profile_id(pid)
|
|
if existing_profile:
|
|
return jsonify({"status": "profile_already_linked"}), 200
|
|
|
|
if not ws_registry.is_connected(pid):
|
|
return jsonify({"status": "not_online"}), 200
|
|
|
|
age = db.discord_link_code_age_seconds(pid)
|
|
if age is not None and age < 60:
|
|
return jsonify({"status": "rate_limited", "retry_after": int(60 - age)}), 200
|
|
|
|
code = db.create_discord_link_code(pid, discord_user_id, discord_username)
|
|
_send_system_message(
|
|
pid,
|
|
f"Your Discord link code is: {code}\nDM this code to the KittyNet bot in Discord. Do NOT post it in a public channel. It expires in 10 minutes.",
|
|
)
|
|
|
|
return jsonify({"status": "sent", "username": profile["Username"]}), 200
|
|
|
|
|
|
@bp.route("/api/internal/discord/confirm", methods=["POST"])
|
|
def discord_confirm():
|
|
if not _check_bot_auth():
|
|
return jsonify({"error": "unauthorized"}), 401
|
|
data = request.get_json(silent=True) or {}
|
|
code = (data.get("code") or "").strip().upper()
|
|
discord_user_id = str(data.get("discord_user_id") or "").strip()
|
|
discord_username = str(data.get("discord_username") or "").strip()
|
|
if not code or not discord_user_id:
|
|
return jsonify({"error": "missing_fields"}), 400
|
|
|
|
existing = db.get_discord_link_by_discord_id(discord_user_id)
|
|
if existing:
|
|
return jsonify({"status": "already_linked"}), 200
|
|
|
|
pid = db.consume_discord_link_code(code, discord_user_id)
|
|
if pid is None:
|
|
return jsonify({"status": "invalid_code"}), 200
|
|
|
|
profile = db.get_profile(pid)
|
|
if not profile:
|
|
return jsonify({"status": "invalid_code"}), 200
|
|
|
|
db.create_discord_link(pid, discord_user_id, discord_username)
|
|
|
|
_send_system_message(
|
|
pid,
|
|
f"Your Discord account has been linked! Welcome, {discord_username}! You're all set.",
|
|
)
|
|
|
|
return jsonify({
|
|
"status": "linked",
|
|
"profile_id": pid,
|
|
"username": profile["Username"],
|
|
"display_name": profile["DisplayName"],
|
|
"level": profile.get("Level", 1),
|
|
}), 200
|
|
|
|
|
|
@bp.route("/portal", methods=["GET", "POST"])
|
|
@limiter.limit("10 per minute")
|
|
def portal_login():
|
|
import secrets as _secrets
|
|
if session.get("portal_pid"):
|
|
return redirect(url_for("portal.portal_me"))
|
|
error = None
|
|
if request.method == "POST":
|
|
token = request.form.get("csrf_token", "")
|
|
if not token or token != session.get("csrf_token"):
|
|
error = "Invalid request. Please try again."
|
|
else:
|
|
username = request.form.get("username", "").strip()
|
|
password = request.form.get("password", "").strip()
|
|
profile = db.check_password(username, password)
|
|
if profile:
|
|
session["portal_pid"] = profile["Id"]
|
|
session.pop("csrf_token", None)
|
|
return redirect(url_for("portal.portal_me"))
|
|
error = "Invalid username or password."
|
|
csrf_token = _secrets.token_hex(16)
|
|
session["csrf_token"] = csrf_token
|
|
return render_template("portal/login.html", error=error, csrf_token=csrf_token)
|
|
|
|
|
|
@bp.route("/portal/me")
|
|
@player_required
|
|
def portal_me():
|
|
pid = session["portal_pid"]
|
|
profile = db.get_profile(pid)
|
|
if not profile:
|
|
session.pop("portal_pid", None)
|
|
return redirect(url_for("portal.portal_login"))
|
|
gifts = db.get_pending_gifts(pid)
|
|
return render_template("portal/profile.html", profile=profile, gifts=gifts)
|
|
|
|
|
|
@bp.route("/portal/logout")
|
|
def portal_logout():
|
|
session.pop("portal_pid", None)
|
|
return redirect(url_for("portal.portal_login"))
|
|
|
|
|
|
@bp.route("/portal/api/consume_gift/<int:gift_id>", methods=["POST"])
|
|
@player_required
|
|
def portal_consume_gift(gift_id):
|
|
pid = session["portal_pid"]
|
|
gift = db.consume_gift(gift_id, pid)
|
|
if gift is None:
|
|
return jsonify({"ok": False})
|
|
if gift.get("AvatarItemDesc"):
|
|
db.unlock_avatar_item(pid, gift["AvatarItemDesc"])
|
|
return jsonify({"ok": True, "xp": gift["Xp"], "item": gift["EquipmentPrefabName"]})
|
|
|
|
|
|
@bp.route("/admin/api/toggle_dev/<int:player_id>", methods=["POST"])
|
|
@require_scope(SCOPE_ADMIN)
|
|
def api_toggle_dev(player_id, account, scopes):
|
|
profile = db.get_profile(player_id)
|
|
if profile is None:
|
|
return jsonify({"error": "Not found"}), 404
|
|
new_val = not profile["Developer"]
|
|
db.set_developer(player_id, new_val)
|
|
print(f"[Admin] {account.get('username')} set player {player_id} developer={new_val}")
|
|
return jsonify({"developer": new_val})
|
|
|
|
|
|
from core.ban_service import cascade_ban as _cascade_ban, cascade_unban as _cascade_unban, kick_player as _kick_player
|
|
|
|
|
|
@bp.route("/admin/api/ban/<int:player_id>", methods=["POST"])
|
|
@require_admin_api
|
|
def api_ban(player_id, account, scopes):
|
|
data = request.get_json(force=True, silent=True) or {}
|
|
reason = data.get("reason", "Banned by admin")[:256]
|
|
duration_h = int(data.get("duration_hours", 0))
|
|
drop_ws = bool(data.get("drop_ws", True))
|
|
admin_name = account.get("username", "admin")
|
|
|
|
if duration_h == 0 and SCOPE_ADMIN not in scopes:
|
|
return jsonify({"error": "Permanent bans require kittyrec.admin scope"}), 403
|
|
|
|
until = db.ban_player(player_id, reason=reason, duration_hours=duration_h, admin_name=admin_name)
|
|
_cascade_ban(player_id, reason, duration_h, admin_name)
|
|
p = db.get_profile(player_id)
|
|
label = "permaban" if duration_h == 0 else f"ban_{duration_h}h"
|
|
db.log_admin_action(admin_name, label, f"Banned {p['Username'] if p else player_id}: {reason}",
|
|
request.headers.get("X-Forwarded-For", request.remote_addr or ""))
|
|
print(f"[Admin] {admin_name} banned player {player_id} reason={reason!r} drop_ws={drop_ws}")
|
|
try:
|
|
from core.discord import send_admin
|
|
uname = p["Username"] if p else str(player_id)
|
|
dur_str = "Permanent" if duration_h == 0 else f"{duration_h}h"
|
|
send_admin(
|
|
title="Player Banned",
|
|
color=0xE74C3C,
|
|
fields=[{"name": "Player", "value": f"{uname} (id={player_id})", "inline": True},
|
|
{"name": "Duration", "value": dur_str, "inline": True},
|
|
{"name": "Reason", "value": reason, "inline": False},
|
|
{"name": "By", "value": admin_name, "inline": True}],
|
|
)
|
|
except Exception:
|
|
pass
|
|
return jsonify({"ok": True, "banned_until": until})
|
|
|
|
|
|
@bp.route("/admin/api/unban/<int:player_id>", methods=["POST"])
|
|
@require_scope(SCOPE_ADMIN)
|
|
def api_unban(player_id, account, scopes):
|
|
name = account.get("username", "admin")
|
|
p = db.get_profile(player_id)
|
|
db.unban_player(player_id, admin_name=name)
|
|
from core.state import db as _db
|
|
ips = [ip for ip in _db.get_ips_for_profile(player_id) if ip not in ("127.0.0.1", "::1")]
|
|
for pid in set(_db.get_all_profiles_for_ips(ips)):
|
|
if _db.is_banned(pid):
|
|
_db.unban_player(pid, admin_name=name)
|
|
from core.anticheat import reset_offenses
|
|
reset_offenses(player_id)
|
|
db.log_admin_action(name, "unban", f"Unbanned {p['Username'] if p else player_id}",
|
|
request.headers.get("X-Forwarded-For", request.remote_addr or ""))
|
|
print(f"[Admin] {name} unbanned player {player_id}")
|
|
try:
|
|
from core.discord import send_admin
|
|
uname = p["Username"] if p else str(player_id)
|
|
send_admin(
|
|
title="Player Unbanned",
|
|
color=0x2ECC71,
|
|
fields=[{"name": "Player", "value": f"{uname} (id={player_id})", "inline": True},
|
|
{"name": "By", "value": name, "inline": True}],
|
|
)
|
|
except Exception:
|
|
pass
|
|
return jsonify({"ok": True})
|
|
|
|
|
|
@bp.route("/admin/api/disconnect/<int:player_id>", methods=["POST"])
|
|
@require_admin_api
|
|
def api_disconnect(player_id, account, scopes):
|
|
name = account.get("username", "admin")
|
|
p = db.get_profile(player_id)
|
|
dropped = _kick_player(player_id)
|
|
db.log_admin_action(name, "disconnect", f"Disconnected {p['Username'] if p else player_id}",
|
|
request.headers.get("X-Forwarded-For", request.remote_addr or ""))
|
|
print(f"[Admin] {name} disconnected player {player_id} ws")
|
|
return jsonify({"ok": True, "was_online": dropped})
|
|
|
|
|
|
@bp.route("/admin/api/gift_player/<int:player_id>", methods=["POST"])
|
|
@require_scope(SCOPE_ADMIN)
|
|
def api_gift_player(player_id, account, scopes):
|
|
data = request.get_json(force=True, silent=True) or {}
|
|
xp = int(data.get("xp", 0))
|
|
rarity = int(data.get("rarity", 0))
|
|
level = int(data.get("level", 0))
|
|
currency_type = int(data.get("currency_type", 0))
|
|
currency = int(data.get("currency", 0))
|
|
gift = db.add_gift(
|
|
player_id,
|
|
xp=xp,
|
|
gift_rarity=rarity,
|
|
level=level,
|
|
currency_type=currency_type,
|
|
currency=currency,
|
|
equipment_prefab_name=data.get("prefab", ""),
|
|
equipment_modification_guid=data.get("guid", ""),
|
|
avatar_item_desc=data.get("avatar_item_desc", ""),
|
|
consumable_item_desc=data.get("consumable_item_desc", ""),
|
|
message=data.get("message", "Gift from KittyRec admin"),
|
|
gift_context=0,
|
|
)
|
|
push_gift(player_id, gift)
|
|
name = account.get("username", "admin")
|
|
ip = request.headers.get("X-Forwarded-For", request.remote_addr or "")
|
|
parts = []
|
|
if xp: parts.append(f"{xp} XP")
|
|
if level: parts.append(f"{level} levels")
|
|
if currency: parts.append(f"{currency} tokens")
|
|
if data.get("consumable_item_desc"): parts.append(f"consumable:{data['consumable_item_desc'][:20]}")
|
|
if data.get("avatar_item_desc"): parts.append(f"item:{data['avatar_item_desc'][:20]}")
|
|
if data.get("prefab"): parts.append(f"equip:{data['prefab']}")
|
|
detail = ", ".join(parts) or "gift"
|
|
db.log_admin_action(name, "gift_player", f"Gifted {detail} to player {player_id}", ip)
|
|
print(f"[Admin] {name} gifted player {player_id}: {detail}")
|
|
return jsonify(gift)
|
|
|
|
|
|
@bp.route("/admin/api/reroll_store", methods=["POST"])
|
|
@require_scope(SCOPE_ADMIN)
|
|
def api_reroll_store(account, scopes):
|
|
from routes.storefronts import reroll_store
|
|
offset = reroll_store()
|
|
name = account.get("username", "admin")
|
|
db.log_admin_action(name, "reroll_store", f"Rerolled store (offset={offset})",
|
|
request.headers.get("X-Forwarded-For", request.remote_addr or ""))
|
|
print(f"[Admin] {name} rerolled store (offset={offset})")
|
|
try:
|
|
from core.discord import send_admin
|
|
send_admin(
|
|
title="Store Rerolled",
|
|
color=0x9B59B6,
|
|
fields=[{"name": "By", "value": name, "inline": True},
|
|
{"name": "Seed Offset", "value": str(offset), "inline": True}],
|
|
)
|
|
except Exception:
|
|
pass
|
|
return jsonify({"ok": True, "offset": offset})
|
|
|
|
|
|
@bp.route("/admin/api/send_message", methods=["POST"])
|
|
@require_scope(SCOPE_ADMIN)
|
|
def api_send_message(account, scopes):
|
|
data = request.get_json(force=True, silent=True) or {}
|
|
target_id = data.get("player_id")
|
|
message = str(data.get("message", ""))
|
|
broadcast = data.get("broadcast", False)
|
|
if not message:
|
|
return jsonify({"error": "No message provided"}), 400
|
|
import datetime
|
|
sent_to = []
|
|
if broadcast:
|
|
for p in db.get_all_profiles_summary():
|
|
_send_system_message(p["id"], message)
|
|
sent_to.append(p["id"])
|
|
elif target_id:
|
|
_send_system_message(int(target_id), message)
|
|
sent_to.append(int(target_id))
|
|
else:
|
|
return jsonify({"error": "No player_id or broadcast flag"}), 400
|
|
name = account.get("username", "admin")
|
|
scope = "broadcast" if broadcast else f"player {target_id}"
|
|
db.log_admin_action(name, "send_notification",
|
|
f"Sent notification to {len(sent_to)} player(s) [{scope}]: {message[:80]}",
|
|
request.headers.get("X-Forwarded-For", request.remote_addr or ""))
|
|
print(f"[Admin] {name} sent message to {len(sent_to)} player(s): {message[:80]}")
|
|
return jsonify({"ok": True, "sent_to": len(sent_to)})
|
|
|
|
|
|
def _send_chat_dm(to_pid: int, text: str) -> None:
|
|
msg_type = 30
|
|
msg_id = db.send_message(_KITTYREC_SYSTEM_ID, to_pid, msg_type, text)
|
|
msg_dict = {
|
|
"Id": msg_id, "FromPlayerId": _KITTYREC_SYSTEM_ID,
|
|
"SentTime": _now_iso(), "Type": msg_type, "Data": text,
|
|
"RoomId": None, "PlayerEventId": None,
|
|
}
|
|
ws_registry.send(to_pid, {"Id": 2, "Msg": msg_dict})
|
|
|
|
|
|
@bp.route("/admin/api/send_dm", methods=["POST"])
|
|
@require_scope(SCOPE_ADMIN)
|
|
def api_send_dm(account, scopes):
|
|
data = request.get_json(force=True, silent=True) or {}
|
|
target_id = data.get("player_id")
|
|
message = str(data.get("message", "")).strip()
|
|
broadcast = data.get("broadcast", False)
|
|
if not message:
|
|
return jsonify({"error": "No message provided"}), 400
|
|
sent_to = []
|
|
if broadcast:
|
|
for p in db.get_all_profiles_summary():
|
|
_send_chat_dm(p["id"], message)
|
|
sent_to.append(p["id"])
|
|
elif target_id:
|
|
pid = int(target_id)
|
|
_send_chat_dm(pid, message)
|
|
sent_to.append(pid)
|
|
else:
|
|
return jsonify({"error": "No player_id or broadcast flag"}), 400
|
|
name = account.get("username", "admin")
|
|
scope = "broadcast" if broadcast else f"player {target_id}"
|
|
db.log_admin_action(name, "send_dm",
|
|
f"Sent DM to {len(sent_to)} player(s) [{scope}]: {message[:80]}",
|
|
request.headers.get("X-Forwarded-For", request.remote_addr or ""))
|
|
print(f"[Admin] {name} sent chat DM to {len(sent_to)} player(s): {message[:80]}")
|
|
return jsonify({"ok": True, "sent_to": len(sent_to)})
|
|
|
|
|
|
@bp.route("/admin/api/reset_password/<int:player_id>", methods=["POST"])
|
|
@require_scope(SCOPE_ADMIN)
|
|
def api_reset_password(account, scopes, player_id):
|
|
import secrets, string
|
|
from werkzeug.security import generate_password_hash
|
|
profile = db.get_profile(player_id)
|
|
if not profile:
|
|
return jsonify({"error": "Player not found"}), 404
|
|
alphabet = string.ascii_letters + string.digits
|
|
temp_pass = "".join(secrets.choice(alphabet) for _ in range(8))
|
|
conn = db._get_conn()
|
|
conn.execute("UPDATE profiles SET password=?, must_change_password=1 WHERE id=?",
|
|
(generate_password_hash(temp_pass), player_id))
|
|
conn.commit()
|
|
from tracking.password_tracking import clear_password_set
|
|
clear_password_set(player_id)
|
|
username = profile.get("Username", f"Player{player_id}")
|
|
from core.system_messages import send_and_await
|
|
send_and_await(player_id,
|
|
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 update it!",
|
|
"password_change", expires_in=0)
|
|
name = account.get("username", "admin")
|
|
db.log_admin_action(name, "reset_password", f"Reset password for {username} (id={player_id})", request.remote_addr)
|
|
print(f"[Admin] {name} reset password for pid={player_id} ({username})")
|
|
try:
|
|
from core.discord import send_admin
|
|
send_admin(
|
|
title="Password Reset",
|
|
color=0xE67E22,
|
|
fields=[{"name": "Player", "value": f"{username} (id={player_id})", "inline": True},
|
|
{"name": "By", "value": name, "inline": True}],
|
|
)
|
|
except Exception:
|
|
pass
|
|
return jsonify({"ok": True, "username": username, "temp_password": temp_pass})
|
|
|
|
|
|
@bp.route("/admin/api/gift_all", methods=["POST"])
|
|
@require_scope(SCOPE_ADMIN)
|
|
def api_gift_all(account, scopes):
|
|
data = request.get_json(force=True, silent=True) or {}
|
|
profiles = db.get_all_profiles_summary()
|
|
for p in profiles:
|
|
gift = db.add_gift(
|
|
p["id"],
|
|
xp=int(data.get("xp", 1000)),
|
|
gift_rarity=int(data.get("rarity", 1)),
|
|
equipment_prefab_name=data.get("prefab", ""),
|
|
equipment_modification_guid=data.get("guid", ""),
|
|
avatar_item_desc=data.get("avatar_item_desc", ""),
|
|
consumable_item_desc=data.get("consumable_item_desc", ""),
|
|
message=data.get("message", "Gift from KittyRec admin"),
|
|
gift_context=0,
|
|
)
|
|
push_gift(p["id"], gift)
|
|
name = account.get("username", "admin")
|
|
db.log_admin_action(name, "gift_all", f"Gifted all {len(profiles)} players ({data.get('xp',1000)} XP)",
|
|
request.headers.get("X-Forwarded-For", request.remote_addr or ""))
|
|
print(f"[Admin] {name} gifted all {len(profiles)} players")
|
|
try:
|
|
from core.discord import send_admin
|
|
send_admin(
|
|
title="Gift All Players",
|
|
color=0x9B59B6,
|
|
fields=[{"name": "By", "value": name, "inline": True},
|
|
{"name": "Players", "value": str(len(profiles)), "inline": True},
|
|
{"name": "XP", "value": str(data.get("xp", 1000)), "inline": True}],
|
|
)
|
|
except Exception:
|
|
pass
|
|
return jsonify({"count": len(profiles)})
|
|
|
|
|
|
@bp.route("/admin/api/stats")
|
|
@require_admin_api
|
|
def api_stats(account, scopes):
|
|
conn = db._get_conn()
|
|
pending = conn.execute("SELECT COUNT(*) AS c FROM gifts WHERE consumed=0").fetchone()["c"]
|
|
banned = conn.execute("SELECT COUNT(*) AS c FROM profiles WHERE banned=1").fetchone()["c"]
|
|
recent = db.get_admin_action_log(limit=10)
|
|
return jsonify({
|
|
"online": len(ws_registry.connected_ids()),
|
|
"sessions": len(session_mgr.all_public_sessions()),
|
|
"pending_gifts": pending,
|
|
"banned": banned,
|
|
"recent_actions": recent,
|
|
"total_playtime_seconds": db.get_total_playtime(),
|
|
})
|
|
|
|
|
|
@bp.route("/admin/api/playtime_leaderboard")
|
|
@require_admin_api
|
|
def api_playtime_leaderboard(account, scopes):
|
|
rows = db.get_playtime_leaderboard(limit=20)
|
|
return jsonify(rows)
|
|
|
|
|
|
@bp.route("/admin/api/online_players")
|
|
@require_admin_api
|
|
def api_online_players(account, scopes):
|
|
online_ids = ws_registry.connected_ids()
|
|
profiles_map = db.get_profiles_batch(online_ids)
|
|
result = []
|
|
for pid in online_ids:
|
|
p = profiles_map.get(pid)
|
|
if p:
|
|
s = session_mgr.get_player_session(pid)
|
|
result.append({
|
|
"id": p["Id"],
|
|
"username": p["Username"],
|
|
"display_name": p["DisplayName"],
|
|
"level": p["Level"],
|
|
"room": s.name if s else "Unknown",
|
|
"activity": s.activity_key if s else "",
|
|
})
|
|
return jsonify(result)
|
|
|
|
|
|
@bp.route("/admin/api/search_players")
|
|
@require_admin_api
|
|
def api_search_players(account, scopes):
|
|
q = request.args.get("q", "").strip()
|
|
profiles = db.search_profiles(q, limit=20)
|
|
online_ids = set(ws_registry.connected_ids())
|
|
result = []
|
|
for p in profiles:
|
|
result.append({
|
|
"id": p["Id"],
|
|
"username": p["Username"],
|
|
"display_name": p["DisplayName"],
|
|
"level": p["Level"],
|
|
"online": p["Id"] in online_ids,
|
|
})
|
|
return jsonify(result)
|
|
|
|
|
|
@bp.route("/admin/api/player_status/<int:player_id>")
|
|
@require_admin_api
|
|
def api_player_status(player_id, account, scopes):
|
|
p = db.get_profile(player_id)
|
|
if not p:
|
|
return jsonify({"error": "Not found"}), 404
|
|
online_ids = set(ws_registry.connected_ids())
|
|
pt = db.get_playtime(player_id)
|
|
return jsonify({
|
|
"id": p["Id"],
|
|
"username": p["Username"],
|
|
"display_name": p["DisplayName"],
|
|
"level": p["Level"],
|
|
"online": p["Id"] in online_ids,
|
|
"banned": bool(p.get("Banned")),
|
|
"ban_reason": p.get("BanReason") or "",
|
|
"developer": bool(p.get("Developer")),
|
|
"playtime_seconds": pt["total_seconds"],
|
|
"session_count": pt["session_count"],
|
|
})
|
|
|
|
|
|
@bp.route("/admin/api/player_timeline/<int:player_id>")
|
|
@require_admin_api
|
|
def api_player_timeline(player_id, account, scopes):
|
|
p = db.get_profile(player_id)
|
|
if not p:
|
|
return jsonify({"error": "Not found"}), 404
|
|
conn = db._get_conn()
|
|
events = []
|
|
if p.get("CreatedAt"):
|
|
events.append({"type": "account_created", "timestamp": p["CreatedAt"], "detail": "Account registered"})
|
|
for r in conn.execute(
|
|
"SELECT action, reason, admin_name, created_at FROM ban_log WHERE profile_id=? ORDER BY created_at DESC LIMIT 30",
|
|
(player_id,)
|
|
).fetchall():
|
|
detail = (r["reason"] or "") + (" (by " + r["admin_name"] + ")" if r["admin_name"] else "")
|
|
events.append({"type": r["action"], "timestamp": r["created_at"], "detail": detail.strip()})
|
|
for r in conn.execute(
|
|
"SELECT xp, gift_rarity, message, created_at FROM gifts WHERE profile_id=? ORDER BY created_at DESC LIMIT 30",
|
|
(player_id,)
|
|
).fetchall():
|
|
parts = []
|
|
if r["xp"]: parts.append(str(r["xp"]) + " XP")
|
|
if r["message"]: parts.append('"' + r["message"] + '"')
|
|
events.append({"type": "gift", "timestamp": r["created_at"], "detail": ", ".join(parts) or "Gift"})
|
|
events.sort(key=lambda e: e["timestamp"] or "", reverse=True)
|
|
return jsonify(events[:50])
|
|
|
|
|
|
@bp.route("/admin/api/player_notes/<int:player_id>")
|
|
@require_admin_api
|
|
def api_player_notes_get(player_id, account, scopes):
|
|
if not db.get_profile(player_id):
|
|
return jsonify({"error": "Not found"}), 404
|
|
return jsonify(db.get_player_notes(player_id))
|
|
|
|
|
|
@bp.route("/admin/api/player_notes/<int:player_id>", methods=["POST"])
|
|
@require_scope(SCOPE_ADMIN)
|
|
def api_player_notes_add(player_id, account, scopes):
|
|
data = request.get_json(force=True, silent=True) or {}
|
|
note = (data.get("note") or "").strip()
|
|
if not note:
|
|
return jsonify({"error": "Note is empty"}), 400
|
|
if not db.get_profile(player_id):
|
|
return jsonify({"error": "Not found"}), 404
|
|
note_id = db.add_player_note(player_id, note, account.get("username", "admin"))
|
|
return jsonify({"ok": True, "id": note_id})
|
|
|
|
|
|
@bp.route("/admin/api/player_notes/<int:player_id>/<int:note_id>", methods=["DELETE"])
|
|
@require_scope(SCOPE_ADMIN)
|
|
def api_player_notes_delete(player_id, note_id, account, scopes):
|
|
db.delete_player_note(note_id, player_id)
|
|
return jsonify({"ok": True})
|
|
|
|
|
|
@bp.route("/admin/api/shared_ips")
|
|
@require_admin_api
|
|
def api_shared_ips(account, scopes):
|
|
conn = db._get_conn()
|
|
rows = conn.execute(
|
|
"SELECT profile_id FROM ip_logins WHERE ip_address IN "
|
|
"(SELECT ip_address FROM ip_logins GROUP BY ip_address HAVING COUNT(DISTINCT profile_id) > 1) "
|
|
"GROUP BY profile_id"
|
|
).fetchall()
|
|
return jsonify([r["profile_id"] for r in rows])
|
|
|
|
|
|
@bp.route("/admin/api/anticheat_suspects")
|
|
@require_admin_api
|
|
def api_anticheat_suspects(account, scopes):
|
|
from core.anticheat import get_suspects
|
|
return jsonify(get_suspects())
|
|
|
|
|
|
@bp.route("/admin/api/player_security/<int:player_id>")
|
|
@require_admin_api
|
|
def api_player_security(player_id, account, scopes):
|
|
if not db.get_profile(player_id):
|
|
return jsonify({"error": "Not found"}), 404
|
|
ips = db.get_ips_for_profile(player_id)
|
|
assoc = db.get_associated_accounts_with_evidence(player_id)
|
|
assoc_profiles = db.get_profiles_batch(list(assoc.keys())) if assoc else {}
|
|
assoc_list = []
|
|
for pid, ev in assoc.items():
|
|
p = assoc_profiles.get(pid)
|
|
if p:
|
|
assoc_list.append({"id": pid, "username": p["Username"], "banned": bool(p.get("Banned")), "shared_ips": ev.get("shared_ips", [])})
|
|
conn = db._get_conn()
|
|
recent_ips = [dict(r) for r in conn.execute(
|
|
"SELECT ip_address, last_seen FROM ip_logins WHERE profile_id=? ORDER BY last_seen DESC LIMIT 10",
|
|
(player_id,)
|
|
).fetchall()]
|
|
return jsonify({"ips": recent_ips, "associated": assoc_list})
|
|
|
|
|
|
@bp.route("/admin/api/discord_info/<int:player_id>")
|
|
@require_admin_api
|
|
def api_discord_info(player_id, account, scopes):
|
|
conn = db._get_conn()
|
|
row = conn.execute("SELECT * FROM discord_links WHERE profile_id=?", (player_id,)).fetchone()
|
|
if not row:
|
|
return jsonify({"linked": False})
|
|
return jsonify({"linked": True, "discord_user_id": row["discord_user_id"], "discord_username": row["discord_username"], "linked_at": row["linked_at"]})
|
|
|
|
|
|
@bp.route("/admin/api/discord_unlink/<int:player_id>", methods=["POST"])
|
|
@require_scope(SCOPE_ADMIN)
|
|
def api_discord_unlink(player_id, account, scopes):
|
|
conn = db._get_conn()
|
|
conn.execute("DELETE FROM discord_links WHERE profile_id=?", (player_id,))
|
|
conn.commit()
|
|
name = account.get("username", "admin")
|
|
db.log_admin_action(name, "discord_unlink", f"Unlinked Discord for player {player_id}",
|
|
request.headers.get("X-Forwarded-For", request.remote_addr or ""))
|
|
return jsonify({"ok": True})
|
|
|
|
|
|
@bp.route("/admin/api/player_inventory/<int:player_id>")
|
|
@require_admin_api
|
|
def api_player_inventory(player_id, account, scopes):
|
|
if not db.get_profile(player_id):
|
|
return jsonify({"error": "Not found"}), 404
|
|
conn = db._get_conn()
|
|
favs = {r["modification_guid"] for r in conn.execute(
|
|
"SELECT modification_guid FROM equipment_favorites WHERE profile_id=?", (player_id,)
|
|
).fetchall()}
|
|
equipment = []
|
|
for r in conn.execute(
|
|
"SELECT equipment_prefab_name, equipment_modification_guid, created_at FROM gifts "
|
|
"WHERE profile_id=? AND equipment_modification_guid != '' AND equipment_modification_guid IS NOT NULL ORDER BY created_at DESC",
|
|
(player_id,)
|
|
).fetchall():
|
|
equipment.append({
|
|
"prefab": r["equipment_prefab_name"],
|
|
"guid": r["equipment_modification_guid"],
|
|
"favorited": r["equipment_modification_guid"] in favs,
|
|
"acquired": r["created_at"],
|
|
})
|
|
avatar_items = [dict(r) for r in conn.execute(
|
|
"SELECT avatar_item_desc, unlocked_at FROM unlocked_items WHERE profile_id=? ORDER BY unlocked_at DESC LIMIT 50",
|
|
(player_id,)
|
|
).fetchall()]
|
|
consumables = [dict(r) for r in conn.execute(
|
|
"SELECT consumable_item_desc, quantity FROM consumable_inventory WHERE profile_id=? AND quantity > 0 ORDER BY consumable_item_desc",
|
|
(player_id,)
|
|
).fetchall()]
|
|
return jsonify({"equipment": equipment, "avatar_items": avatar_items, "consumables": consumables})
|
|
|
|
|
|
@bp.route("/admin/api/revoke_tokens/<int:player_id>", methods=["POST"])
|
|
@require_scope(SCOPE_ADMIN)
|
|
def api_revoke_tokens(player_id, account, scopes):
|
|
conn = db._get_conn()
|
|
count = conn.execute("SELECT COUNT(*) AS c FROM cached_logins WHERE profile_id=?", (player_id,)).fetchone()["c"]
|
|
db.remove_cached_login(player_id)
|
|
name = account.get("username", "admin")
|
|
db.log_admin_action(name, "revoke_tokens", f"Revoked {count} cached token(s) for player {player_id}",
|
|
request.headers.get("X-Forwarded-For", request.remote_addr or ""))
|
|
return jsonify({"ok": True, "revoked": count})
|
|
|
|
|
|
@bp.route("/admin/api/player_chats/<int:player_id>")
|
|
@require_admin_api
|
|
def api_player_chats(player_id, account, scopes):
|
|
if not db.get_profile(player_id):
|
|
return jsonify({"error": "Not found"}), 404
|
|
conn = db._get_conn()
|
|
thread_ids = [r["thread_id"] for r in conn.execute(
|
|
"SELECT thread_id FROM chat_thread_players WHERE profile_id=?", (player_id,)
|
|
).fetchall()]
|
|
if not thread_ids:
|
|
return jsonify([])
|
|
placeholders = ",".join("?" * len(thread_ids))
|
|
rows = conn.execute(
|
|
f"SELECT cm.id, cm.thread_id, cm.sender_id, cm.contents, cm.sent_at, p.username AS sender_username "
|
|
f"FROM chat_messages cm JOIN profiles p ON p.id=cm.sender_id "
|
|
f"WHERE cm.thread_id IN ({placeholders}) ORDER BY cm.sent_at DESC LIMIT 50",
|
|
thread_ids
|
|
).fetchall()
|
|
return jsonify([dict(r) for r in rows])
|
|
|
|
|
|
@bp.route("/admin/api/set_profile_image/<int:player_id>", methods=["POST"])
|
|
@require_scope(SCOPE_ADMIN)
|
|
def api_set_profile_image(player_id, account, scopes):
|
|
from core.ws_helpers import push_profile_update
|
|
f = request.files.get("image")
|
|
if not f:
|
|
return jsonify({"ok": False, "error": "No image provided"}), 400
|
|
image_data = f.read(2 * 1024 * 1024 + 1)
|
|
if not image_data:
|
|
return jsonify({"ok": False, "error": "Empty file"}), 400
|
|
if len(image_data) > 2 * 1024 * 1024:
|
|
return jsonify({"ok": False, "error": "Image too large (max 2MB)"}), 413
|
|
db.set_profile_image(player_id, image_data, str(player_id))
|
|
db.update_profile(player_id, {"profile_image_name": str(player_id)})
|
|
push_profile_update(player_id)
|
|
name = account.get("username", "admin")
|
|
db.log_admin_action(name, "set_profile_image",
|
|
f"Set profile image for player {player_id}",
|
|
request.headers.get("X-Forwarded-For", request.remote_addr or ""))
|
|
return jsonify({"ok": True})
|
|
|
|
|
|
@bp.route("/admin/api/delete_profile_image/<int:player_id>", methods=["POST"])
|
|
@require_scope(SCOPE_ADMIN)
|
|
def api_delete_profile_image(player_id, account, scopes):
|
|
from core.ws_helpers import push_profile_update
|
|
db.set_profile_image(player_id, None)
|
|
db.update_profile(player_id, {"profile_image_name": ""})
|
|
push_profile_update(player_id)
|
|
name = account.get("username", "admin")
|
|
db.log_admin_action(name, "delete_profile_image",
|
|
f"Deleted profile image for player {player_id}",
|
|
request.headers.get("X-Forwarded-For", request.remote_addr or ""))
|
|
return jsonify({"ok": True})
|
|
|
|
|
|
@bp.route("/admin/api/avatar_items")
|
|
@require_admin_api
|
|
def api_avatar_items(account, scopes):
|
|
path = os.path.join(os.path.dirname(__file__), "..", "data", "avataritems.json")
|
|
with open(os.path.normpath(path)) as f:
|
|
items = json.load(f)
|
|
return jsonify(items)
|
|
|
|
|
|
@bp.route("/admin/api/consumables")
|
|
@require_admin_api
|
|
def api_consumables(account, scopes):
|
|
path = os.path.join(os.path.dirname(__file__), "..", "data", "consumables.json")
|
|
with open(os.path.normpath(path)) as f:
|
|
items = json.load(f)
|
|
return jsonify(items)
|
|
|
|
|
|
@bp.route("/admin/api/equipment")
|
|
@require_admin_api
|
|
def api_equipment(account, scopes):
|
|
path = os.path.join(os.path.dirname(__file__), "..", "data", "equipment.json")
|
|
with open(os.path.normpath(path)) as f:
|
|
items = json.load(f)
|
|
return jsonify(items)
|
|
|
|
|
|
@bp.route("/admin/api/maintenance", methods=["GET"])
|
|
@require_admin_api
|
|
def api_maintenance_get(account, scopes):
|
|
with maintenance_lock:
|
|
active = _state.maintenance_mode
|
|
exempt = list(_state.maintenance_exempt)
|
|
with _schedule_lock:
|
|
sat = _scheduled_maintenance_at
|
|
sdur = _scheduled_maintenance_duration_min
|
|
sexempt = list(_scheduled_maintenance_exempt)
|
|
with _reboot_when_empty_lock:
|
|
rwe = _reboot_when_empty
|
|
return jsonify({
|
|
"maintenance": active,
|
|
"exempt_ids": exempt,
|
|
"scheduled_at": sat or None,
|
|
"scheduled_duration_min": sdur,
|
|
"scheduled_exempt_ids": sexempt,
|
|
"reboot_when_empty": rwe,
|
|
})
|
|
|
|
|
|
@bp.route("/admin/api/region", methods=["GET"])
|
|
@require_admin_api
|
|
def api_region_get(account, scopes):
|
|
return jsonify({"region": _state.server_region})
|
|
|
|
|
|
@bp.route("/admin/api/region", methods=["POST"])
|
|
@require_scope(SCOPE_ADMIN)
|
|
def api_region_set(account, scopes):
|
|
data = request.get_json(force=True, silent=True) or {}
|
|
region = str(data.get("region", "")).strip().lower()
|
|
if not region:
|
|
return jsonify({"error": "region required"}), 400
|
|
_state.server_region = region
|
|
name = account.get("username", "admin")
|
|
db.log_admin_action(
|
|
name, "set_region", f"Set server region to '{region}'",
|
|
request.headers.get("X-Forwarded-For", request.remote_addr or ""),
|
|
)
|
|
print(f"[Admin] {name} set server region to '{region}'")
|
|
return jsonify({"ok": True, "region": region})
|
|
|
|
|
|
@bp.route("/admin/api/git_sync", methods=["POST"])
|
|
@require_scope(SCOPE_ADMIN)
|
|
def api_git_sync(account, scopes):
|
|
import subprocess
|
|
name = account.get("username", "admin")
|
|
try:
|
|
result = subprocess.run(
|
|
["git", "pull"],
|
|
cwd="/home/server",
|
|
capture_output=True,
|
|
text=True,
|
|
timeout=30,
|
|
)
|
|
output = (result.stdout + result.stderr).strip()
|
|
ok = result.returncode == 0
|
|
except subprocess.TimeoutExpired:
|
|
output = "git pull timed out after 30 seconds"
|
|
ok = False
|
|
except Exception as e:
|
|
output = str(e)
|
|
ok = False
|
|
db.log_admin_action(
|
|
name, "git_sync", f"Git sync: {'ok' if ok else 'failed'} — {output[:200]}",
|
|
request.headers.get("X-Forwarded-For", request.remote_addr or ""),
|
|
)
|
|
print(f"[Admin] {name} git sync: {output[:200]}")
|
|
try:
|
|
from core.discord import send_admin
|
|
send_admin(
|
|
title=f"Git Sync {'Succeeded' if ok else 'Failed'}",
|
|
color=0x2ECC71 if ok else 0xE74C3C,
|
|
fields=[{"name": "By", "value": name, "inline": True},
|
|
{"name": "Output", "value": f"```{output[:900]}```", "inline": False}],
|
|
)
|
|
except Exception:
|
|
pass
|
|
return jsonify({"ok": ok, "output": output})
|
|
|
|
|
|
@bp.route("/admin/api/reboot", methods=["POST"])
|
|
@require_scope(SCOPE_ADMIN)
|
|
def api_reboot(account, scopes):
|
|
import subprocess, threading
|
|
name = account.get("username", "admin")
|
|
db.log_admin_action(
|
|
name, "reboot", "Server reboot triggered via admin panel",
|
|
request.headers.get("X-Forwarded-For", request.remote_addr or ""),
|
|
)
|
|
print(f"[Admin] {name} triggered server reboot")
|
|
try:
|
|
from core.discord import send_admin
|
|
send_admin(
|
|
title="Server Reboot Triggered",
|
|
color=0xE67E22,
|
|
fields=[{"name": "By", "value": name, "inline": True}],
|
|
)
|
|
except Exception:
|
|
pass
|
|
|
|
def _do_reboot():
|
|
import time as _time
|
|
_time.sleep(1)
|
|
subprocess.run(["systemctl", "restart", "kittyrec"], check=False)
|
|
|
|
threading.Thread(target=_do_reboot, daemon=True).start()
|
|
return jsonify({"ok": True, "message": "Server is restarting..."})
|
|
|
|
|
|
_MAINTENANCE_FILE = os.path.join(os.path.dirname(os.path.dirname(__file__)), "tracking", "settings", "maintenance.json")
|
|
|
|
_scheduled_maintenance_at: float = 0.0
|
|
_scheduled_maintenance_duration_min: int = 0
|
|
_scheduled_maintenance_exempt: list = []
|
|
_schedule_lock = __import__("threading").Lock()
|
|
|
|
_reboot_when_empty: bool = False
|
|
_reboot_when_empty_lock = __import__("threading").Lock()
|
|
|
|
|
|
def _save_maintenance(enabled: bool, exempt_ids: list,
|
|
scheduled_at: float = 0.0,
|
|
scheduled_duration_min: int = 0,
|
|
scheduled_exempt: list = None,
|
|
reboot_when_empty: bool = False) -> None:
|
|
import json as _json
|
|
try:
|
|
with open(_MAINTENANCE_FILE, "w") as f:
|
|
_json.dump({
|
|
"enabled": enabled,
|
|
"exempt_ids": list(exempt_ids),
|
|
"scheduled_at": scheduled_at,
|
|
"scheduled_duration_min": scheduled_duration_min,
|
|
"scheduled_exempt_ids": list(scheduled_exempt or []),
|
|
"reboot_when_empty": reboot_when_empty,
|
|
}, f, indent=2)
|
|
except Exception as e:
|
|
print(f"[Maintenance] Failed to save state: {e}")
|
|
|
|
|
|
def _load_maintenance_schedule():
|
|
global _scheduled_maintenance_at, _scheduled_maintenance_duration_min, _scheduled_maintenance_exempt, _reboot_when_empty
|
|
try:
|
|
with open(_MAINTENANCE_FILE) as f:
|
|
d = __import__("json").load(f)
|
|
with _schedule_lock:
|
|
_scheduled_maintenance_at = float(d.get("scheduled_at", 0))
|
|
_scheduled_maintenance_duration_min = int(d.get("scheduled_duration_min", 0))
|
|
_scheduled_maintenance_exempt = list(d.get("scheduled_exempt_ids", []))
|
|
with _reboot_when_empty_lock:
|
|
_reboot_when_empty = bool(d.get("reboot_when_empty", False))
|
|
except Exception:
|
|
pass
|
|
|
|
|
|
def _maintenance_scheduler():
|
|
global _scheduled_maintenance_at, _scheduled_maintenance_duration_min, _scheduled_maintenance_exempt
|
|
import threading as _threading
|
|
_load_maintenance_schedule()
|
|
while True:
|
|
__import__("time").sleep(30)
|
|
try:
|
|
with _schedule_lock:
|
|
sat = _scheduled_maintenance_at
|
|
sdur = _scheduled_maintenance_duration_min
|
|
sexempt = list(_scheduled_maintenance_exempt)
|
|
if sat and time.time() >= sat and not _state.maintenance_mode:
|
|
with maintenance_lock:
|
|
_state.maintenance_mode = True
|
|
_state.maintenance_exempt = set(int(x) for x in sexempt if str(x).isdigit())
|
|
_save_maintenance(True, list(_state.maintenance_exempt), 0, 0, [])
|
|
with _schedule_lock:
|
|
_scheduled_maintenance_at = 0.0
|
|
_scheduled_maintenance_duration_min = 0
|
|
_scheduled_maintenance_exempt = []
|
|
db.log_admin_action("scheduler", "maintenance_mode", "Scheduled maintenance started", "")
|
|
_broadcast_system_message("— Server maintenance has started. You may be disconnected shortly.")
|
|
if sdur:
|
|
import threading as _t
|
|
def _auto_disable(_dur=sdur):
|
|
__import__("time").sleep(_dur * 60)
|
|
if _state.maintenance_mode:
|
|
with maintenance_lock:
|
|
_state.maintenance_mode = False
|
|
_state.maintenance_exempt.clear()
|
|
_save_maintenance(False, [])
|
|
db.log_admin_action("scheduler", "maintenance_mode", "Scheduled maintenance ended", "")
|
|
_broadcast_system_message("— Server maintenance has ended. Welcome back!")
|
|
_t.Thread(target=_auto_disable, daemon=True).start()
|
|
try:
|
|
from core.discord import send_admin
|
|
send_admin(title="Scheduled Maintenance Started", color=0xE67E22, fields=[])
|
|
except Exception:
|
|
pass
|
|
except Exception as e:
|
|
print(f"[MaintenanceScheduler] error: {e}")
|
|
|
|
|
|
__import__("threading").Thread(target=_maintenance_scheduler, daemon=True, name="maint-scheduler").start()
|
|
|
|
|
|
def _reboot_when_empty_watcher():
|
|
global _reboot_when_empty
|
|
import subprocess as _sp, json as _json
|
|
while True:
|
|
__import__("time").sleep(10)
|
|
try:
|
|
try:
|
|
with open(_MAINTENANCE_FILE) as _f:
|
|
armed = bool(_json.load(_f).get("reboot_when_empty", False))
|
|
except Exception:
|
|
armed = False
|
|
with _reboot_when_empty_lock:
|
|
_reboot_when_empty = armed
|
|
if not armed:
|
|
continue
|
|
if ws_registry.player_count() > 0:
|
|
continue
|
|
print("[RebootWatcher] No players online — rebooting now")
|
|
with _reboot_when_empty_lock:
|
|
_reboot_when_empty = False
|
|
with maintenance_lock:
|
|
_save_maintenance(
|
|
_state.maintenance_mode,
|
|
list(_state.maintenance_exempt),
|
|
_scheduled_maintenance_at,
|
|
_scheduled_maintenance_duration_min,
|
|
_scheduled_maintenance_exempt,
|
|
reboot_when_empty=False,
|
|
)
|
|
db.log_admin_action("system", "reboot", "Deferred reboot — server empty", "")
|
|
try:
|
|
from core.discord import send_admin
|
|
send_admin(title="Deferred Reboot", color=0xE67E22,
|
|
fields=[{"name": "Trigger", "value": "Server became empty", "inline": True}])
|
|
except Exception:
|
|
pass
|
|
__import__("time").sleep(1)
|
|
_sp.run(["systemctl", "restart", "kittyrec"], check=False)
|
|
except Exception as e:
|
|
print(f"[RebootWatcher] Error: {e}")
|
|
|
|
|
|
__import__("threading").Thread(target=_reboot_when_empty_watcher, daemon=True, name="reboot-watcher").start()
|
|
|
|
|
|
@bp.route("/admin/api/reboot_when_empty", methods=["GET"])
|
|
@require_admin_api
|
|
def api_reboot_when_empty_get(account, scopes):
|
|
with _reboot_when_empty_lock:
|
|
armed = _reboot_when_empty
|
|
return jsonify({"reboot_when_empty": armed})
|
|
|
|
|
|
@bp.route("/admin/api/reboot_when_empty", methods=["POST"])
|
|
@require_scope(SCOPE_ADMIN)
|
|
def api_reboot_when_empty_set(account, scopes):
|
|
global _reboot_when_empty
|
|
data = request.get_json(force=True, silent=True) or {}
|
|
value = bool(data.get("enabled", False))
|
|
with _reboot_when_empty_lock:
|
|
_reboot_when_empty = value
|
|
with maintenance_lock:
|
|
_save_maintenance(
|
|
_state.maintenance_mode,
|
|
list(_state.maintenance_exempt),
|
|
_scheduled_maintenance_at,
|
|
_scheduled_maintenance_duration_min,
|
|
_scheduled_maintenance_exempt,
|
|
reboot_when_empty=value,
|
|
)
|
|
name = account.get("username", "admin")
|
|
db.log_admin_action(name, "reboot", f"Deferred reboot {'armed' if value else 'disarmed'}",
|
|
request.headers.get("X-Forwarded-For", request.remote_addr or ""))
|
|
print(f"[Admin] {name} {'armed' if value else 'disarmed'} deferred reboot")
|
|
return jsonify({"ok": True, "reboot_when_empty": value})
|
|
|
|
|
|
@bp.route("/admin/api/maintenance", methods=["POST"])
|
|
@require_scope(SCOPE_ADMIN)
|
|
def api_maintenance_set(account, scopes):
|
|
data = request.get_json(force=True, silent=True) or {}
|
|
enabled = bool(data.get("enabled", False))
|
|
exempt_ids = data.get("exempt_ids", [])
|
|
with maintenance_lock:
|
|
_state.maintenance_mode = enabled
|
|
if enabled:
|
|
_state.maintenance_exempt = set(int(x) for x in exempt_ids if str(x).isdigit())
|
|
else:
|
|
_state.maintenance_exempt.clear()
|
|
with _schedule_lock:
|
|
sat = _scheduled_maintenance_at
|
|
sdur = _scheduled_maintenance_duration_min
|
|
sexempt = list(_scheduled_maintenance_exempt)
|
|
_save_maintenance(enabled, list(_state.maintenance_exempt), sat, sdur, sexempt)
|
|
db.log_admin_action(
|
|
account.get("username", "admin"),
|
|
"maintenance_mode",
|
|
f"Maintenance mode {'enabled' if enabled else 'disabled'}",
|
|
request.headers.get("X-Forwarded-For", request.remote_addr or ""),
|
|
)
|
|
print(f"[Admin] Maintenance mode {'ON' if enabled else 'OFF'} by {account.get('username')}")
|
|
try:
|
|
from core.discord import send_admin
|
|
send_admin(
|
|
title=f"Maintenance Mode {'Enabled' if enabled else 'Disabled'}",
|
|
color=0xE67E22 if enabled else 0x2ECC71,
|
|
fields=[{"name": "By", "value": account.get("username", "admin"), "inline": True},
|
|
{"name": "Exempt IDs", "value": str(list(_state.maintenance_exempt)) or "none", "inline": True}],
|
|
)
|
|
except Exception:
|
|
pass
|
|
return jsonify({"ok": True, "maintenance": enabled})
|
|
|
|
|
|
@bp.route("/admin/api/maintenance/schedule", methods=["POST"])
|
|
@require_scope(SCOPE_ADMIN)
|
|
def api_maintenance_schedule(account, scopes):
|
|
global _scheduled_maintenance_at, _scheduled_maintenance_duration_min, _scheduled_maintenance_exempt
|
|
data = request.get_json(force=True, silent=True) or {}
|
|
action = data.get("action", "set")
|
|
if action == "clear":
|
|
with _schedule_lock:
|
|
_scheduled_maintenance_at = 0.0
|
|
_scheduled_maintenance_duration_min = 0
|
|
_scheduled_maintenance_exempt = []
|
|
with maintenance_lock:
|
|
_save_maintenance(_state.maintenance_mode, list(_state.maintenance_exempt), 0, 0, [])
|
|
db.log_admin_action(account.get("username", "admin"), "maintenance_schedule", "Cleared scheduled maintenance",
|
|
request.headers.get("X-Forwarded-For", request.remote_addr or ""))
|
|
return jsonify({"ok": True, "scheduled_at": None})
|
|
scheduled_at_iso = data.get("scheduled_at", "")
|
|
duration_min = int(data.get("duration_min", 0))
|
|
exempt_ids = [int(x) for x in data.get("exempt_ids", []) if str(x).isdigit() or (isinstance(x, int))]
|
|
if not scheduled_at_iso:
|
|
return jsonify({"error": "scheduled_at required"}), 400
|
|
try:
|
|
import datetime as _dt
|
|
dt = _dt.datetime.fromisoformat(scheduled_at_iso.replace("Z", "+00:00"))
|
|
sat = dt.timestamp()
|
|
except Exception:
|
|
return jsonify({"error": "invalid scheduled_at format, use ISO 8601"}), 400
|
|
if sat <= time.time():
|
|
return jsonify({"error": "scheduled_at must be in the future"}), 400
|
|
with _schedule_lock:
|
|
_scheduled_maintenance_at = sat
|
|
_scheduled_maintenance_duration_min = duration_min
|
|
_scheduled_maintenance_exempt = exempt_ids
|
|
with maintenance_lock:
|
|
_save_maintenance(_state.maintenance_mode, list(_state.maintenance_exempt), sat, duration_min, exempt_ids)
|
|
db.log_admin_action(account.get("username", "admin"), "maintenance_schedule",
|
|
f"Scheduled maintenance at {scheduled_at_iso} for {duration_min}min",
|
|
request.headers.get("X-Forwarded-For", request.remote_addr or ""))
|
|
return jsonify({"ok": True, "scheduled_at": sat})
|
|
|
|
|
|
@bp.route("/admin/api/rooms/create", methods=["POST"])
|
|
@require_scope(SCOPE_ADMIN)
|
|
def api_create_room(account, scopes):
|
|
data = request.get_json(force=True, silent=True) or {}
|
|
level_id = str(data.get("level_id", "")).strip()
|
|
name = str(data.get("name", "")).strip()
|
|
owner_pid = data.get("owner_pid")
|
|
if not level_id or not name:
|
|
return jsonify({"error": "level_id and name are required"}), 400
|
|
try:
|
|
owner_pid = int(owner_pid) if owner_pid else 1
|
|
except (ValueError, TypeError):
|
|
return jsonify({"error": "owner_pid must be an integer"}), 400
|
|
room = db.create_room(creator_id=owner_pid, name=name, activity_level_id=level_id)
|
|
admin_name = account.get("username", "admin")
|
|
db.log_admin_action(admin_name, "create_room", f"Created room '{name}' (level_id={level_id}, owner={owner_pid})",
|
|
request.headers.get("X-Forwarded-For", request.remote_addr or ""))
|
|
print(f"[Admin] {admin_name} created room '{name}' level_id={level_id} owner={owner_pid}")
|
|
return jsonify({"ok": True, "room_id": room["RoomId"]})
|
|
|
|
|
|
@bp.route("/admin/api/rooms/<int:room_id>", methods=["GET"])
|
|
@require_admin_api
|
|
def api_get_room(room_id, account, scopes):
|
|
room = db.get_room(room_id)
|
|
if not room:
|
|
return jsonify({"error": "Room not found"}), 404
|
|
return jsonify(room)
|
|
|
|
|
|
@bp.route("/admin/api/rooms/<int:room_id>", methods=["PUT"])
|
|
@require_scope(SCOPE_ADMIN)
|
|
def api_update_room(room_id, account, scopes):
|
|
data = request.get_json(force=True, silent=True) or {}
|
|
room = db.get_room(room_id)
|
|
if not room:
|
|
return jsonify({"error": "Room not found"}), 404
|
|
updates = {}
|
|
for key in ("name", "description", "activity_level_id", "max_players",
|
|
"is_sandbox", "instanced", "accessibility", "state",
|
|
"special_gamemode", "creator_id",
|
|
"unity_asset_bundle_url", "unity_scene_name"):
|
|
if key in data:
|
|
val = data[key]
|
|
if key in ("max_players", "accessibility", "state", "special_gamemode", "creator_id"):
|
|
val = int(val)
|
|
elif key in ("is_sandbox", "instanced"):
|
|
val = 1 if val else 0
|
|
updates[key] = val
|
|
if not updates:
|
|
return jsonify({"error": "No fields to update"}), 400
|
|
room = db.update_room(room_id, **updates)
|
|
admin_name = account.get("username", "admin")
|
|
changed = ", ".join(f"{k}={v}" for k, v in updates.items())
|
|
db.log_admin_action(admin_name, "edit_room",
|
|
f"Edited room {room_id} ({room['Name']}): {changed}",
|
|
request.headers.get("X-Forwarded-For", request.remote_addr or ""))
|
|
print(f"[Admin] {admin_name} edited room {room_id}: {changed}")
|
|
return jsonify({"ok": True, "room": room})
|
|
|
|
|
|
@bp.route("/admin/api/rooms/<int:room_id>", methods=["DELETE"])
|
|
@require_scope(SCOPE_ADMIN)
|
|
def api_delete_room(room_id, account, scopes):
|
|
room = db.get_room(room_id)
|
|
if not room:
|
|
return jsonify({"error": "Room not found"}), 404
|
|
db.delete_room(room_id)
|
|
admin_name = account.get("username", "admin")
|
|
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 ""))
|
|
print(f"[Admin] {admin_name} deleted room {room_id} ({room['Name']})")
|
|
return jsonify({"ok": True})
|
|
|
|
|
|
@bp.route("/admin/api/rooms/<int:room_id>/image", methods=["POST"])
|
|
@require_scope(SCOPE_ADMIN)
|
|
def api_upload_room_image(room_id, account, scopes):
|
|
import uuid, io
|
|
from PIL import Image
|
|
room = db.get_room(room_id)
|
|
if not room:
|
|
return jsonify({"error": "Room not found"}), 404
|
|
f = request.files.get("image")
|
|
if not f:
|
|
return jsonify({"error": "No image file provided"}), 400
|
|
image_data = f.read(2 * 1024 * 1024 + 1)
|
|
if len(image_data) > 2 * 1024 * 1024:
|
|
return jsonify({"error": "Image too large (max 2MB)"}), 400
|
|
TARGET_W, TARGET_H = 1280, 720
|
|
try:
|
|
img = Image.open(io.BytesIO(image_data))
|
|
img = img.convert("RGB")
|
|
src_w, src_h = img.size
|
|
src_ratio = src_w / src_h
|
|
target_ratio = TARGET_W / TARGET_H
|
|
if src_ratio > target_ratio:
|
|
new_h = src_h
|
|
new_w = int(src_h * target_ratio)
|
|
left = (src_w - new_w) // 2
|
|
img = img.crop((left, 0, left + new_w, new_h))
|
|
elif src_ratio < target_ratio:
|
|
new_w = src_w
|
|
new_h = int(src_w / target_ratio)
|
|
top = (src_h - new_h) // 2
|
|
img = img.crop((0, top, new_w, top + new_h))
|
|
img = img.resize((TARGET_W, TARGET_H), Image.LANCZOS)
|
|
buf = io.BytesIO()
|
|
img.save(buf, format="JPEG", quality=85)
|
|
image_data = buf.getvalue()
|
|
except Exception:
|
|
pass
|
|
image_name = f"room_{room_id}_{uuid.uuid4().hex[:8]}"
|
|
db.save_named_image(image_name, 0, image_data, room_name=room["Name"])
|
|
db.update_room_field(room_id, "image_name", image_name)
|
|
admin_name = account.get("username", "admin")
|
|
db.log_admin_action(admin_name, "upload_room_image",
|
|
f"Uploaded image for room '{room['Name']}' (id={room_id}, image={image_name})",
|
|
request.headers.get("X-Forwarded-For", request.remote_addr or ""))
|
|
print(f"[Admin] {admin_name} uploaded image for room {room_id}: {image_name}")
|
|
return jsonify({"ok": True, "image_name": image_name})
|
|
|
|
|
|
@bp.route("/admin/api/rooms/<int:room_id>/permissions", methods=["GET"])
|
|
@require_admin_api
|
|
def api_room_permissions_get(room_id, account, scopes):
|
|
room = db.get_room(room_id)
|
|
if not room:
|
|
return jsonify({"error": "Room not found"}), 404
|
|
perms = db.get_room_permissions(room_id)
|
|
result = []
|
|
for p in perms:
|
|
profile = db.get_profile(p["player_id"])
|
|
result.append({
|
|
"player_id": p["player_id"],
|
|
"username": profile["username"] if profile else f"#{p['player_id']}",
|
|
"is_host": bool(p["is_host"]),
|
|
"is_owner": bool(p["is_owner"]),
|
|
})
|
|
return jsonify({"ok": True, "permissions": result, "creator_id": room.get("CreatorId") or room.get("creator_id")})
|
|
|
|
|
|
@bp.route("/admin/api/rooms/<int:room_id>/permissions", methods=["POST"])
|
|
@require_scope(SCOPE_ADMIN)
|
|
def api_room_permissions_set(room_id, account, scopes):
|
|
room = db.get_room(room_id)
|
|
if not room:
|
|
return jsonify({"error": "Room not found"}), 404
|
|
data = request.get_json(force=True, silent=True) or {}
|
|
player_id = data.get("player_id")
|
|
if not player_id:
|
|
return jsonify({"error": "player_id required"}), 400
|
|
try:
|
|
player_id = int(player_id)
|
|
except (ValueError, TypeError):
|
|
return jsonify({"error": "player_id must be integer"}), 400
|
|
is_host = bool(data.get("is_host", False))
|
|
is_owner = bool(data.get("is_owner", False))
|
|
db.set_room_permission(room_id, player_id, is_host, is_owner)
|
|
db.log_admin_action(account.get("username", "admin"), "room_permission",
|
|
f"Set room {room_id} perms for player {player_id}: host={is_host} owner={is_owner}",
|
|
request.headers.get("X-Forwarded-For", request.remote_addr or ""))
|
|
return jsonify({"ok": True})
|
|
|
|
|
|
@bp.route("/admin/api/rooms/<int:room_id>/permissions/<int:player_id>", methods=["DELETE"])
|
|
@require_scope(SCOPE_ADMIN)
|
|
def api_room_permissions_del(room_id, player_id, account, scopes):
|
|
room = db.get_room(room_id)
|
|
if not room:
|
|
return jsonify({"error": "Room not found"}), 404
|
|
db.set_room_permission(room_id, player_id, False, False)
|
|
db.log_admin_action(account.get("username", "admin"), "room_permission",
|
|
f"Removed room {room_id} perms for player {player_id}",
|
|
request.headers.get("X-Forwarded-For", request.remote_addr or ""))
|
|
return jsonify({"ok": True})
|
|
|
|
|
|
@bp.route("/admin/api/rooms/<int:room_id>/disabled", methods=["POST"])
|
|
@require_scope(SCOPE_ADMIN)
|
|
def api_set_room_disabled(room_id, account, scopes):
|
|
data = request.get_json(force=True, silent=True) or {}
|
|
disabled = bool(data.get("disabled", False))
|
|
room = db.get_room(room_id)
|
|
if not room:
|
|
return jsonify({"error": "Room not found"}), 404
|
|
db.set_room_disabled(room_id, disabled)
|
|
admin_name = account.get("username", "admin")
|
|
action = "disabled" if disabled else "enabled"
|
|
db.log_admin_action(admin_name, "toggle_room_disabled",
|
|
f"{action.title()} joins for room {room_id} ({room['Name']})",
|
|
request.headers.get("X-Forwarded-For", request.remote_addr or ""))
|
|
print(f"[Admin] {admin_name} {action} joins for room {room_id}")
|
|
return jsonify({"ok": True, "disabled": disabled})
|
|
|
|
|
|
@bp.route("/admin/api/player_social/<int:pid>")
|
|
@require_admin_api
|
|
def api_player_social(pid, account, scopes):
|
|
from core.constants import REL_FRIEND, REL_SENT, REL_RECEIVED
|
|
rels = db.get_relationships(pid)
|
|
friends, sent, received, muted, ignored = [], [], [], [], []
|
|
for r in rels:
|
|
target_id = r["PlayerID"]
|
|
profile = db.get_profile(target_id)
|
|
entry = {
|
|
"id": target_id,
|
|
"username": profile["Username"] if profile else f"#{target_id}",
|
|
"banned": bool(profile["Banned"]) if profile else False,
|
|
}
|
|
rt = r.get("RelationshipType", 0)
|
|
if rt == REL_FRIEND:
|
|
friends.append(entry)
|
|
elif rt == REL_SENT:
|
|
sent.append(entry)
|
|
elif rt == REL_RECEIVED:
|
|
received.append(entry)
|
|
if r.get("Muted"):
|
|
muted.append(entry)
|
|
if r.get("Ignored"):
|
|
ignored.append(entry)
|
|
subs = db.get_subscriptions(pid)
|
|
subscribers = [{"id": s["PlayerId"], "username": s["Username"]} for s in subs]
|
|
sub_count = db.get_subscriber_count(pid)
|
|
return jsonify({
|
|
"friends": friends,
|
|
"pending_sent": sent,
|
|
"pending_received": received,
|
|
"muted": muted,
|
|
"ignored": ignored,
|
|
"subscribers": subscribers,
|
|
"subscriber_count": sub_count,
|
|
})
|
|
|
|
|
|
@bp.route("/admin/api/player_gift_caps/<int:pid>")
|
|
@require_admin_api
|
|
def api_player_gift_caps(pid, account, scopes):
|
|
import datetime as _dt
|
|
today = _dt.datetime.utcnow().strftime("%Y-%m-%d")
|
|
today_count = db.get_daily_gift_count(pid, today)
|
|
conn = db._get_conn()
|
|
rows = conn.execute(
|
|
"SELECT date_str, COUNT(*) as cnt FROM daily_gifts WHERE profile_id=? GROUP BY date_str ORDER BY date_str DESC LIMIT 14",
|
|
(pid,)
|
|
).fetchall()
|
|
history = [{"date": r["date_str"], "count": r["cnt"]} for r in rows]
|
|
session_count = db.get_session_gift_count(pid, "")
|
|
return jsonify({"today": today_count, "today_date": today, "history": history})
|
|
|
|
|
|
@bp.route("/admin/api/player_gift_caps/<int:pid>/reset", methods=["POST"])
|
|
@require_scope(SCOPE_ADMIN)
|
|
def api_player_gift_caps_reset(pid, account, scopes):
|
|
import datetime as _dt
|
|
data = request.get_json(force=True, silent=True) or {}
|
|
date_str = data.get("date") or _dt.datetime.utcnow().strftime("%Y-%m-%d")
|
|
conn = db._get_conn()
|
|
conn.execute("DELETE FROM daily_gifts WHERE profile_id=? AND date_str=?", (pid, date_str))
|
|
conn.commit()
|
|
db.reset_session_gift_counts(pid)
|
|
db.log_admin_action(account.get("username", "admin"), "reset_gift_cap",
|
|
f"Reset gift cap for player {pid} on {date_str}",
|
|
request.headers.get("X-Forwarded-For", request.remote_addr or ""))
|
|
return jsonify({"ok": True, "date": date_str})
|
|
|
|
|
|
@bp.route("/admin/api/cdn/files", methods=["GET"])
|
|
@require_admin_api
|
|
def api_cdn_list(account, scopes):
|
|
conn = db._get_conn()
|
|
rows = conn.execute(
|
|
"SELECT name, length(image_data) as size, created_at, room_name FROM saved_images WHERE profile_id = -1 ORDER BY created_at DESC"
|
|
).fetchall()
|
|
files = []
|
|
for r in rows:
|
|
files.append({
|
|
"name": r["name"],
|
|
"size": r["size"],
|
|
"created_at": r["created_at"],
|
|
"label": r["room_name"] if "room_name" in r.keys() else "",
|
|
})
|
|
return jsonify(files)
|
|
|
|
|
|
@bp.route("/admin/api/cdn/upload", methods=["POST"])
|
|
@require_scope(SCOPE_ADMIN)
|
|
def api_cdn_upload(account, scopes):
|
|
import uuid
|
|
f = request.files.get("file")
|
|
if not f:
|
|
return jsonify({"error": "No file provided"}), 400
|
|
file_data = f.read(10 * 1024 * 1024 + 1)
|
|
if len(file_data) > 10 * 1024 * 1024:
|
|
return jsonify({"error": "File too large (max 10MB)"}), 400
|
|
custom_name = request.form.get("name", "").strip()
|
|
if custom_name:
|
|
import re
|
|
custom_name = re.sub(r'[^a-zA-Z0-9_\-.]', '_', custom_name)
|
|
else:
|
|
ext = ""
|
|
if f.filename and "." in f.filename:
|
|
ext = "." + f.filename.rsplit(".", 1)[1].lower()
|
|
custom_name = f"cdn_{uuid.uuid4().hex[:12]}{ext}"
|
|
label = request.form.get("label", "").strip() or f.filename or ""
|
|
db.save_named_image(custom_name, -1, file_data, room_name=label)
|
|
base = f"{_base_url}/{custom_name}"
|
|
admin_name = account.get("username", "admin")
|
|
db.log_admin_action(admin_name, "cdn_upload",
|
|
f"Uploaded CDN file '{custom_name}' ({len(file_data)} bytes)",
|
|
request.headers.get("X-Forwarded-For", request.remote_addr or ""))
|
|
print(f"[CDN] {admin_name} uploaded: {custom_name} ({len(file_data)} bytes)")
|
|
return jsonify({"ok": True, "name": custom_name, "url": base})
|
|
|
|
|
|
@bp.route("/admin/api/cdn/delete", methods=["POST"])
|
|
@require_scope(SCOPE_ADMIN)
|
|
def api_cdn_delete(account, scopes):
|
|
data = request.get_json(force=True, silent=True) or {}
|
|
name = data.get("name", "")
|
|
if not name:
|
|
return jsonify({"error": "No name provided"}), 400
|
|
conn = db._get_conn()
|
|
conn.execute("DELETE FROM saved_images WHERE name = ? AND profile_id = -1", (name,))
|
|
conn.commit()
|
|
admin_name = account.get("username", "admin")
|
|
db.log_admin_action(admin_name, "cdn_delete",
|
|
f"Deleted CDN file '{name}'",
|
|
request.headers.get("X-Forwarded-For", request.remote_addr or ""))
|
|
return jsonify({"ok": True})
|
|
|
|
|
|
_DLL_DIR = os.path.join(os.path.dirname(os.path.dirname(__file__)), "kittyrec_dlls")
|
|
_DLL_JSON = os.path.join(os.path.dirname(os.path.dirname(__file__)), "data", "KittyRecDlls.json")
|
|
_BRANCH_NAMES = {
|
|
"bff0c094-2d59-4f81-93dd-fc6f177ca584": "Prod",
|
|
"fb4ce906-59c1-4ffd-af5e-6696dfad1be2": "Dev",
|
|
"f94fa96b-7438-4323-825f-ff4dc4055db1": "BVT",
|
|
}
|
|
|
|
|
|
def _read_dll_json():
|
|
try:
|
|
with open(_DLL_JSON) as f:
|
|
return json.load(f)
|
|
except Exception:
|
|
return {}
|
|
|
|
|
|
def _write_dll_json(data):
|
|
with open(_DLL_JSON, "w") as f:
|
|
json.dump(data, f, indent=4)
|
|
|
|
|
|
@bp.route("/admin/api/dll_archive", methods=["GET"])
|
|
@require_admin_api
|
|
def api_dll_archive_list(account, scopes):
|
|
entries = db.dll_archive_list()
|
|
dll_data = _read_dll_json()
|
|
active = {v["file"]: _BRANCH_NAMES.get(k, k) for k, v in dll_data.items() if isinstance(v, dict) and "file" in v}
|
|
for e in entries:
|
|
e["branch"] = active.get(e["filename"], "")
|
|
return jsonify(entries)
|
|
|
|
|
|
@bp.route("/admin/api/dll_archive/upload", methods=["POST"])
|
|
@require_scope(SCOPE_ADMIN)
|
|
def api_dll_archive_upload(account, scopes):
|
|
import uuid, hashlib
|
|
f = request.files.get("file")
|
|
if not f:
|
|
return jsonify({"error": "No file provided"}), 400
|
|
if not (f.filename or "").endswith(".dll"):
|
|
return jsonify({"error": "Must be a .dll file"}), 400
|
|
data = f.read()
|
|
sha = hashlib.sha512(data).hexdigest()
|
|
filename = f"{uuid.uuid4()}.dll"
|
|
fpath = os.path.join(_DLL_DIR, filename)
|
|
os.makedirs(_DLL_DIR, exist_ok=True)
|
|
with open(fpath, "wb") as fh:
|
|
fh.write(data)
|
|
label = request.form.get("label", "").strip()
|
|
admin_name = account.get("username", "admin")
|
|
db.dll_archive_add(filename, sha, label, len(data), admin_name)
|
|
db.log_admin_action(admin_name, "dll_upload", f"Uploaded DLL '{filename}' ({len(data)} bytes)", request.headers.get("X-Forwarded-For", request.remote_addr or ""))
|
|
print(f"[DLL] {admin_name} uploaded: {filename} ({len(data)} bytes)")
|
|
return jsonify({"ok": True, "filename": filename, "sha512": sha})
|
|
|
|
|
|
@bp.route("/admin/api/dll_archive/assign", methods=["POST"])
|
|
@require_scope(SCOPE_ADMIN)
|
|
def api_dll_archive_assign(account, scopes):
|
|
data = request.get_json(force=True, silent=True) or {}
|
|
filename = data.get("filename", "")
|
|
branch_id = data.get("branch_id", "")
|
|
if not filename or branch_id not in _BRANCH_NAMES:
|
|
return jsonify({"error": "Invalid filename or branch_id"}), 400
|
|
sha = ""
|
|
for e in db.dll_archive_list():
|
|
if e["filename"] == filename:
|
|
sha = e["sha512"]
|
|
break
|
|
if not sha:
|
|
return jsonify({"error": "DLL not found in archive"}), 404
|
|
dll_data = _read_dll_json()
|
|
dll_data[branch_id] = {"file": filename, "hash": sha}
|
|
_write_dll_json(dll_data)
|
|
admin_name = account.get("username", "admin")
|
|
db.log_admin_action(admin_name, "dll_assign", f"Assigned '{filename}' to branch {_BRANCH_NAMES[branch_id]}", request.headers.get("X-Forwarded-For", request.remote_addr or ""))
|
|
return jsonify({"ok": True})
|
|
|
|
|
|
@bp.route("/admin/api/dll_archive/update_label", methods=["POST"])
|
|
@require_scope(SCOPE_ADMIN)
|
|
def api_dll_archive_update_label(account, scopes):
|
|
data = request.get_json(force=True, silent=True) or {}
|
|
filename = data.get("filename", "")
|
|
label = str(data.get("label", ""))[:200]
|
|
if not filename:
|
|
return jsonify({"error": "Missing filename"}), 400
|
|
db.dll_archive_update(filename, label)
|
|
return jsonify({"ok": True})
|
|
|
|
|
|
@bp.route("/admin/api/gamemode_defaults", methods=["GET"])
|
|
@require_admin_api
|
|
def api_get_gamemode_defaults(account, scopes):
|
|
return jsonify(db.get_all_gamemode_defaults())
|
|
|
|
|
|
@bp.route("/admin/api/gamemode_defaults", methods=["POST"])
|
|
@require_scope(SCOPE_ADMIN)
|
|
def api_set_gamemode_default(account, scopes):
|
|
data = request.get_json(force=True, silent=True) or {}
|
|
activity_level_id = str(data.get("activity_level_id", "")).strip()
|
|
special_gamemode = int(data.get("special_gamemode", 0))
|
|
if not activity_level_id:
|
|
return jsonify({"error": "activity_level_id required"}), 400
|
|
db.set_gamemode_default(activity_level_id, special_gamemode)
|
|
admin_name = account.get("username", "admin")
|
|
db.log_admin_action(admin_name, "set_gamemode_default",
|
|
f"Set gamemode default for {activity_level_id}: {special_gamemode}",
|
|
request.headers.get("X-Forwarded-For", request.remote_addr or ""))
|
|
print(f"[Admin] {admin_name} set gamemode default {activity_level_id}={special_gamemode}")
|
|
return jsonify({"ok": True})
|
|
|
|
|
|
@bp.route("/admin/api/disabled_activities", methods=["GET"])
|
|
@require_admin_api
|
|
def api_get_disabled_activities(account, scopes):
|
|
return jsonify(db.get_all_disabled_activities())
|
|
|
|
|
|
@bp.route("/admin/api/disabled_activities", methods=["POST"])
|
|
@require_scope(SCOPE_ADMIN)
|
|
def api_set_disabled_activity(account, scopes):
|
|
data = request.get_json(force=True, silent=True) or {}
|
|
activity_level_id = str(data.get("activity_level_id", "")).strip()
|
|
disabled = bool(data.get("disabled", False))
|
|
if not activity_level_id:
|
|
return jsonify({"error": "activity_level_id required"}), 400
|
|
db.set_activity_disabled(activity_level_id, disabled)
|
|
admin_name = account.get("username", "admin")
|
|
action = "disabled" if disabled else "enabled"
|
|
db.log_admin_action(admin_name, "toggle_activity",
|
|
f"{action.title()} activity {activity_level_id}",
|
|
request.headers.get("X-Forwarded-For", request.remote_addr or ""))
|
|
print(f"[Admin] {admin_name} {action} activity {activity_level_id}")
|
|
return jsonify({"ok": True, "disabled": disabled})
|
|
|
|
|
|
@bp.route("/admin/api/events", methods=["GET"])
|
|
@require_admin_api
|
|
def api_list_events(account, scopes):
|
|
return jsonify(db.get_all_events())
|
|
|
|
@bp.route("/admin/api/events", methods=["POST"])
|
|
@require_scope(SCOPE_ADMIN)
|
|
def api_create_event(account, scopes):
|
|
data = request.get_json(force=True, silent=True) or {}
|
|
name = data.get("name", "").strip()
|
|
if not name:
|
|
return jsonify({"ok": False, "error": "Name required"}), 400
|
|
eid = db.create_event(
|
|
name=name,
|
|
description=data.get("description", ""),
|
|
start_time=data.get("start_time", ""),
|
|
end_time=data.get("end_time", ""),
|
|
poster_image=data.get("poster_image", ""),
|
|
creator_player_id=int(data.get("creator_player_id", 1)),
|
|
activity_level_id=data.get("activity_level_id", ""),
|
|
)
|
|
print(f"[Admin] Event created: {name} (id={eid}) by {account.get('username')}")
|
|
return jsonify({"ok": True, "id": eid})
|
|
|
|
@bp.route("/admin/api/events/<int:eid>", methods=["PUT"])
|
|
@require_scope(SCOPE_ADMIN)
|
|
def api_update_event(account, scopes, eid):
|
|
data = request.get_json(force=True, silent=True) or {}
|
|
db.update_event(eid, **data)
|
|
return jsonify({"ok": True})
|
|
|
|
@bp.route("/admin/api/events/<int:eid>", methods=["DELETE"])
|
|
@require_scope(SCOPE_ADMIN)
|
|
def api_delete_event(account, scopes, eid):
|
|
db.delete_event(eid)
|
|
print(f"[Admin] Event {eid} deleted by {account.get('username')}")
|
|
return jsonify({"ok": True})
|
|
|
|
|
|
_CLIENT_LOG_DIR = os.path.join(os.path.dirname(os.path.dirname(__file__)), "uploads", "clientlogs")
|
|
|
|
|
|
@bp.route("/admin/api/clientlogs", methods=["GET"])
|
|
@require_admin_api
|
|
def api_list_clientlogs(account, scopes):
|
|
try:
|
|
files = sorted(os.listdir(_CLIENT_LOG_DIR), reverse=True)
|
|
except FileNotFoundError:
|
|
files = []
|
|
result = []
|
|
for name in files:
|
|
path = os.path.join(_CLIENT_LOG_DIR, name)
|
|
try:
|
|
size = os.path.getsize(path)
|
|
except OSError:
|
|
size = 0
|
|
result.append({"name": name, "size": size})
|
|
return jsonify(result)
|
|
|
|
|
|
@bp.route("/admin/api/clientlogs/<path:filename>", methods=["GET"])
|
|
@require_admin_api
|
|
def api_download_clientlog(filename, account, scopes):
|
|
safe = os.path.basename(filename)
|
|
path = os.path.join(_CLIENT_LOG_DIR, safe)
|
|
if not os.path.isfile(path):
|
|
return Response("Not Found", 404)
|
|
with open(path, "rb") as f:
|
|
data = f.read()
|
|
return Response(data, 200, {
|
|
"Content-Type": "text/plain; charset=utf-8",
|
|
"Content-Disposition": f"attachment; filename={safe}",
|
|
})
|
|
|
|
|
|
|
|
|
|
@bp.route("/admin/api/create_mural", methods=["POST"])
|
|
@require_scope(SCOPE_ADMIN)
|
|
def api_create_mural(account, scopes):
|
|
import os, math, io, time
|
|
from PIL import Image as _Image
|
|
_HD_DIR = os.path.join(os.path.dirname(__file__), "..", "uploads", "images", "hd")
|
|
_HD_DIR = os.path.abspath(_HD_DIR)
|
|
files = [f for f in os.listdir(_HD_DIR) if os.path.isfile(os.path.join(_HD_DIR, f))]
|
|
if not files:
|
|
return jsonify({"ok": False, "error": "No HD images found"}), 404
|
|
imgs = []
|
|
for fname in files:
|
|
try:
|
|
img = _Image.open(os.path.join(_HD_DIR, fname)).convert("RGB")
|
|
imgs.append(img)
|
|
except Exception:
|
|
pass
|
|
if not imgs:
|
|
return jsonify({"ok": False, "error": "Could not open any images"}), 500
|
|
W, H = 3840, 2160
|
|
n = len(imgs)
|
|
avg_ar = sum(img.width / img.height for img in imgs) / n
|
|
n_rows = max(1, round(math.sqrt(n * avg_ar * H / W)))
|
|
n_rows = min(n_rows, n)
|
|
per_row = [n // n_rows] * n_rows
|
|
for i in range(n % n_rows):
|
|
per_row[i] += 1
|
|
groups, raw_heights = [], []
|
|
idx = 0
|
|
for cnt in per_row:
|
|
group = imgs[idx:idx + cnt]
|
|
idx += cnt
|
|
total_ar = sum(img.width / img.height for img in group)
|
|
groups.append((group, total_ar))
|
|
raw_heights.append(W / total_ar)
|
|
h_scale = H / sum(raw_heights)
|
|
mural = _Image.new("RGB", (W, H))
|
|
y = 0
|
|
for (group, total_ar), rh in zip(groups, raw_heights):
|
|
row_h = round(rh * h_scale)
|
|
x = 0
|
|
for j, img in enumerate(group):
|
|
ar = img.width / img.height
|
|
tile_w = W - x if j == len(group) - 1 else round(ar / total_ar * W)
|
|
tile_w = max(1, tile_w)
|
|
resized = img.resize((tile_w, row_h), _Image.LANCZOS)
|
|
mural.paste(resized, (x, y))
|
|
x += tile_w
|
|
y += row_h
|
|
out_name = f"mural_{int(time.time())}.jpg"
|
|
out_path = os.path.join(os.path.dirname(__file__), "..", "uploads", "mural", out_name)
|
|
os.makedirs(os.path.dirname(out_path), exist_ok=True)
|
|
mural.save(out_path, "JPEG", quality=88)
|
|
name = account.get("username", "admin")
|
|
db.log_admin_action(name, "create_mural", f"Created mural with {len(imgs)} photos → {out_name}",
|
|
request.headers.get("X-Forwarded-For", request.remote_addr or ""))
|
|
return jsonify({"ok": True, "filename": out_name, "count": len(imgs), "rows": n_rows})
|
|
|
|
|
|
@bp.route("/admin/mural/")
|
|
@require_admin_api
|
|
def list_murals(account, scopes):
|
|
import os
|
|
mural_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), "..", "uploads", "mural"))
|
|
os.makedirs(mural_dir, exist_ok=True)
|
|
files = sorted(
|
|
[f for f in os.listdir(mural_dir) if os.path.isfile(os.path.join(mural_dir, f))],
|
|
reverse=True,
|
|
)
|
|
items = []
|
|
for f in files:
|
|
stat = os.stat(os.path.join(mural_dir, f))
|
|
items.append({
|
|
"filename": f,
|
|
"url": f"/admin/mural/{f}",
|
|
"size_kb": round(stat.st_size / 1024),
|
|
"created": int(stat.st_mtime),
|
|
})
|
|
return jsonify({"murals": items, "count": len(items)})
|
|
|
|
|
|
@bp.route("/admin/mural/<path:filename>")
|
|
@require_admin_api
|
|
def serve_mural(filename, account, scopes):
|
|
import os
|
|
from flask import send_from_directory
|
|
mural_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), "..", "uploads", "mural"))
|
|
return send_from_directory(mural_dir, filename)
|
|
|
|
|
|
def _require_admin_ui():
|
|
from core.admin_auth import get_admin_account, has_any_admin_scope, make_login_redirect
|
|
account, scopes = get_admin_account()
|
|
if not account or not has_any_admin_scope(scopes):
|
|
return None, None, redirect(make_login_redirect())
|
|
return account, scopes, None
|
|
|
|
|
|
@bp.route("/admin/players")
|
|
def admin_players_page():
|
|
account, scopes, redir = _require_admin_ui()
|
|
if redir:
|
|
return redir
|
|
profiles = db.get_all_profiles_summary()
|
|
online_ids = set(ws_registry.connected_ids())
|
|
return render_template(
|
|
"admin/players.html",
|
|
profiles=profiles, online_ids=online_ids,
|
|
account=account, scopes=scopes, SCOPE_ADMIN=SCOPE_ADMIN,
|
|
)
|
|
|
|
|
|
@bp.route("/admin/players/<int:pid>")
|
|
def admin_player_detail_page(pid):
|
|
account, scopes, redir = _require_admin_ui()
|
|
if redir:
|
|
return redir
|
|
profile = db.get_profile(pid)
|
|
if not profile:
|
|
return "Player not found", 404
|
|
ban_log = db.get_ban_log(profile_id=pid, limit=30)
|
|
conn = db._get_conn()
|
|
gifts = [dict(r) for r in conn.execute(
|
|
"SELECT * FROM gifts WHERE profile_id=? ORDER BY id DESC LIMIT 30", (pid,)
|
|
).fetchall()]
|
|
is_online = pid in ws_registry.connected_ids()
|
|
cur_session = session_mgr.get_player_session(pid) if is_online else None
|
|
return render_template(
|
|
"admin/player_detail.html",
|
|
profile=profile, ban_log=ban_log, gifts=gifts,
|
|
is_online=is_online, cur_session=cur_session,
|
|
account=account, scopes=scopes, SCOPE_ADMIN=SCOPE_ADMIN,
|
|
)
|
|
|
|
|
|
@bp.route("/admin/bans")
|
|
def admin_bans_page():
|
|
account, scopes, redir = _require_admin_ui()
|
|
if redir:
|
|
return redir
|
|
conn = db._get_conn()
|
|
banned = [dict(r) for r in conn.execute(
|
|
"SELECT * FROM profiles WHERE banned=1 ORDER BY id DESC"
|
|
).fetchall()]
|
|
ban_log = db.get_ban_log(limit=100)
|
|
return render_template(
|
|
"admin/bans.html",
|
|
banned=banned, ban_log=ban_log,
|
|
account=account, scopes=scopes, SCOPE_ADMIN=SCOPE_ADMIN,
|
|
)
|
|
|
|
|
|
@bp.route("/admin/sessions")
|
|
def admin_sessions_page():
|
|
account, scopes, redir = _require_admin_ui()
|
|
if redir:
|
|
return redir
|
|
active = session_mgr.all_public_sessions()
|
|
all_pids = [pid for s in active for pid in s.players]
|
|
profiles_map = db.get_profiles_batch(all_pids)
|
|
session_details = []
|
|
for s in active:
|
|
players = [profiles_map[pid] for pid in s.players if pid in profiles_map]
|
|
session_details.append({"session": s, "players": players})
|
|
return render_template(
|
|
"admin/sessions.html",
|
|
session_details=session_details,
|
|
online_count=len(ws_registry.connected_ids()),
|
|
account=account, scopes=scopes, SCOPE_ADMIN=SCOPE_ADMIN,
|
|
)
|
|
|
|
|
|
@bp.route("/admin/gifts")
|
|
def admin_gifts_page():
|
|
account, scopes, redir = _require_admin_ui()
|
|
if redir:
|
|
return redir
|
|
conn = db._get_conn()
|
|
gifts = [dict(r) for r in conn.execute(
|
|
"SELECT g.*, p.username FROM gifts g LEFT JOIN profiles p ON p.id = g.profile_id ORDER BY g.id DESC LIMIT 500"
|
|
).fetchall()]
|
|
pending = sum(1 for g in gifts if not g.get("consumed"))
|
|
return render_template(
|
|
"admin/gifts.html",
|
|
gifts=gifts, pending=pending, total=len(gifts),
|
|
account=account, scopes=scopes, SCOPE_ADMIN=SCOPE_ADMIN,
|
|
)
|
|
|
|
|
|
@bp.route("/admin/chat")
|
|
def admin_chat_page():
|
|
account, scopes, redir = _require_admin_ui()
|
|
if redir:
|
|
return redir
|
|
threads = db.get_all_chat_threads(limit=200)
|
|
return render_template(
|
|
"admin/chat.html",
|
|
threads=threads,
|
|
account=account, scopes=scopes, SCOPE_ADMIN=SCOPE_ADMIN,
|
|
)
|
|
|
|
|
|
@bp.route("/admin/leaderboard")
|
|
def admin_leaderboard_page():
|
|
account, scopes, redir = _require_admin_ui()
|
|
if redir:
|
|
return redir
|
|
entries = db.get_leaderboard_with_usernames(objective_type=1, limit=100)
|
|
return render_template(
|
|
"admin/leaderboard.html",
|
|
entries=entries,
|
|
account=account, scopes=scopes, SCOPE_ADMIN=SCOPE_ADMIN,
|
|
)
|
|
|
|
|
|
@bp.route("/admin/api/chat_threads")
|
|
@require_admin_api
|
|
def api_chat_threads(account, scopes):
|
|
threads = db.get_all_chat_threads(limit=200)
|
|
return jsonify(threads)
|
|
|
|
|
|
@bp.route("/admin/api/chat_thread/<int:tid>")
|
|
@require_admin_api
|
|
def api_chat_thread_messages(account, scopes, tid):
|
|
messages = db.get_chat_messages_admin(tid, limit=100)
|
|
players = db.get_chat_thread_players(tid)
|
|
return jsonify({"messages": messages, "player_ids": players})
|
|
|
|
|
|
@bp.route("/admin/api/chat_message/<int:mid>", methods=["DELETE"])
|
|
@require_scope(SCOPE_ADMIN)
|
|
def api_delete_chat_message(account, scopes, mid):
|
|
db.delete_chat_message(mid)
|
|
db.log_admin_action(
|
|
account.get("username", "admin"), "delete_chat_message",
|
|
f"Deleted chat message #{mid}",
|
|
request.headers.get("X-Forwarded-For", request.remote_addr or ""),
|
|
)
|
|
return jsonify({"ok": True})
|
|
|
|
|
|
@bp.route("/admin/api/sanitize_log")
|
|
@require_admin_api
|
|
def api_sanitize_log(account, scopes):
|
|
from routes.misc import get_sanitize_log
|
|
entries = get_sanitize_log()
|
|
pids = list({e["pid"] for e in entries if e.get("pid")})
|
|
profiles = db.get_profiles_batch(pids) if pids else {}
|
|
for e in entries:
|
|
pid = e.get("pid")
|
|
p = profiles.get(pid)
|
|
e["username"] = p.get("Username", f"#{pid}") if p else (f"#{pid}" if pid else "?")
|
|
return jsonify(entries)
|
|
|
|
|
|
@bp.route("/admin/api/player_settings/<int:pid>", methods=["GET"])
|
|
@require_admin_api
|
|
def api_player_settings_get(account, scopes, pid):
|
|
settings = db.get_settings(pid)
|
|
return jsonify(settings)
|
|
|
|
|
|
@bp.route("/admin/api/player_settings/<int:pid>", methods=["POST"])
|
|
@require_scope(SCOPE_ADMIN)
|
|
def api_player_settings_set(account, scopes, pid):
|
|
data = request.get_json(force=True, silent=True) or {}
|
|
action = data.get("action", "set")
|
|
key = str(data.get("key", "")).strip()
|
|
if not key:
|
|
return jsonify({"error": "key required"}), 400
|
|
if action == "delete":
|
|
db.remove_setting(pid, key)
|
|
db.log_admin_action(
|
|
account.get("username", "admin"), "delete_setting",
|
|
f"Deleted setting {key!r} for player #{pid}",
|
|
request.headers.get("X-Forwarded-For", request.remote_addr or ""),
|
|
)
|
|
else:
|
|
value = str(data.get("value", ""))
|
|
db.set_setting(pid, key, value)
|
|
if key == "Recroom.OOBE":
|
|
db.update_profile(pid, {"registration_status": 2})
|
|
db.log_admin_action(
|
|
account.get("username", "admin"), "set_setting",
|
|
f"Set {key!r}={value!r} for player #{pid}",
|
|
request.headers.get("X-Forwarded-For", request.remote_addr or ""),
|
|
)
|
|
return jsonify({"ok": True})
|
|
|
|
|
|
@bp.route("/admin/api/force_oobe/<int:pid>", methods=["POST"])
|
|
@require_scope(SCOPE_ADMIN)
|
|
def api_force_oobe(account, scopes, pid):
|
|
db.set_setting(pid, "Recroom.OOBE", "100")
|
|
db.update_profile(pid, {"registration_status": 2})
|
|
db.log_admin_action(
|
|
account.get("username", "admin"), "force_oobe",
|
|
f"Forced OOBE completion for player #{pid}",
|
|
request.headers.get("X-Forwarded-For", request.remote_addr or ""),
|
|
)
|
|
return jsonify({"ok": True})
|
|
|
|
|
|
@bp.route("/admin/api/force_screen_mode/<int:pid>", methods=["POST"])
|
|
@require_scope(SCOPE_ADMIN)
|
|
def api_force_screen_mode(account, scopes, pid):
|
|
data = request.get_json(force=True, silent=True) or {}
|
|
enabled = bool(data.get("enabled", True))
|
|
db.set_setting(pid, "screen_mode_user", "1" if enabled else "0")
|
|
db.log_admin_action(
|
|
account.get("username", "admin"), "force_screen_mode",
|
|
f"Set screen_mode_user={'1' if enabled else '0'} for player #{pid}",
|
|
request.headers.get("X-Forwarded-For", request.remote_addr or ""),
|
|
)
|
|
return jsonify({"ok": True, "screen_mode": enabled})
|
|
|
|
|
|
@bp.route("/admin/api/bulk_action", methods=["POST"])
|
|
@require_admin_api
|
|
def api_bulk_action(account, scopes, **kwargs):
|
|
data = request.get_json(force=True, silent=True) or {}
|
|
action = data.get("action", "")
|
|
pids = [int(x) for x in data.get("pids", []) if str(x).isdigit()]
|
|
if not pids or not action:
|
|
return jsonify({"error": "action and pids required"}), 400
|
|
if action in ("ban", "unban", "gift") and SCOPE_ADMIN not in scopes:
|
|
return jsonify({"error": "Admin scope required"}), 403
|
|
name = account.get("username", "admin")
|
|
ip = request.headers.get("X-Forwarded-For", request.remote_addr or "")
|
|
results = {"ok": 0, "fail": 0}
|
|
if action == "disconnect":
|
|
for pid in pids:
|
|
try:
|
|
ws_registry.disconnect(pid)
|
|
results["ok"] += 1
|
|
except Exception:
|
|
results["fail"] += 1
|
|
db.log_admin_action(name, "bulk_disconnect", f"Disconnected {results['ok']} players", ip)
|
|
elif action == "ban":
|
|
reason = str(data.get("reason", "Bulk ban"))[:256]
|
|
duration_h = int(data.get("duration_hours", 24))
|
|
for pid in pids:
|
|
try:
|
|
db.ban_player(pid, reason, name, duration_h if duration_h > 0 else None)
|
|
results["ok"] += 1
|
|
except Exception:
|
|
results["fail"] += 1
|
|
db.log_admin_action(name, "bulk_ban", f"Banned {results['ok']} players: {reason}", ip)
|
|
elif action == "unban":
|
|
for pid in pids:
|
|
try:
|
|
db.unban_player(pid, name)
|
|
results["ok"] += 1
|
|
except Exception:
|
|
results["fail"] += 1
|
|
db.log_admin_action(name, "bulk_unban", f"Unbanned {results['ok']} players", ip)
|
|
elif action == "gift":
|
|
from core.ws_helpers import push_gift
|
|
xp = max(0, min(int(data.get("xp", 1000)), 99999))
|
|
rarity = int(data.get("rarity", 0))
|
|
message = str(data.get("message", ""))[:80]
|
|
for pid in pids:
|
|
try:
|
|
gift = db.add_gift(pid, xp=xp, gift_rarity=rarity, message=message, gift_context=5)
|
|
push_gift(pid, gift)
|
|
results["ok"] += 1
|
|
except Exception:
|
|
results["fail"] += 1
|
|
db.log_admin_action(name, "bulk_gift", f"Gifted {results['ok']} players ({xp} XP)", ip)
|
|
else:
|
|
return jsonify({"error": "unknown action"}), 400
|
|
return jsonify({"ok": True, "results": results})
|
|
|
|
|
|
@bp.route("/admin/api/leaderboard_data")
|
|
@require_admin_api
|
|
def api_leaderboard_data(account, scopes):
|
|
obj = int(request.args.get("objective", 1))
|
|
entries = db.get_leaderboard_with_usernames(objective_type=obj, limit=100)
|
|
return jsonify(entries)
|
|
|
|
|
|
@bp.route("/admin/api/reset_leaderboard", methods=["POST"])
|
|
@require_scope(SCOPE_ADMIN)
|
|
def api_reset_leaderboard(account, scopes):
|
|
data = request.get_json(force=True, silent=True) or {}
|
|
obj = data.get("objective")
|
|
db.reset_leaderboard_periodic(objective_type=obj)
|
|
name = account.get("username", "admin")
|
|
label = f"objective={obj}" if obj is not None else "all objectives"
|
|
db.log_admin_action(
|
|
name, "reset_leaderboard", f"Reset periodic leaderboard scores ({label})",
|
|
request.headers.get("X-Forwarded-For", request.remote_addr or ""),
|
|
)
|
|
return jsonify({"ok": True})
|
|
|
|
|
|
_BOT_ANALYTICS_PATH = "/home/kittyrecbots/KittyNet-DiscordBot/analytics.json"
|
|
|
|
|
|
@bp.route("/admin/live/discord")
|
|
def admin_discord_page():
|
|
account, scopes, redir = _require_admin_ui()
|
|
if redir:
|
|
return redir
|
|
return render_template("admin/discord_view.html", account=account, scopes=scopes, SCOPE_ADMIN=SCOPE_ADMIN)
|
|
|
|
|
|
@bp.route("/admin/api/discord_analytics")
|
|
@require_admin_api
|
|
def api_discord_analytics(account, scopes):
|
|
import json as _json
|
|
from datetime import datetime, timezone, timedelta
|
|
from collections import defaultdict as _dd
|
|
|
|
try:
|
|
with open(_BOT_ANALYTICS_PATH) as _f:
|
|
data = _json.load(_f)
|
|
except Exception as exc:
|
|
return jsonify({"error": str(exc)}), 500
|
|
|
|
now = datetime.now(timezone.utc)
|
|
snapshots = data.get("snapshots", [])
|
|
latest = snapshots[-1] if snapshots else {}
|
|
members = latest.get("member_count", 0)
|
|
|
|
week_ago = now - timedelta(days=7)
|
|
recent = [s for s in snapshots if datetime.fromisoformat(s["timestamp"]) >= week_ago]
|
|
growth_7d = (recent[-1].get("member_count", 0) - recent[0].get("member_count", 0)) if len(recent) >= 2 else 0
|
|
|
|
hourly = data.get("hourly_messages", {})
|
|
total_messages = sum(h.get("total", 0) for h in hourly.values())
|
|
discord_links = data.get("discord_links", {})
|
|
voice_sessions = data.get("voice_sessions", [])
|
|
active_voice = data.get("active_voice", {})
|
|
|
|
summary = {
|
|
"members": members,
|
|
"growth_7d": growth_7d,
|
|
"total_messages": total_messages,
|
|
"linked_accounts": len(discord_links),
|
|
"voice_sessions": len(voice_sessions),
|
|
"active_voice": len(active_voice),
|
|
}
|
|
|
|
step = max(1, len(snapshots) // 150)
|
|
growth = [{"t": s["timestamp"], "c": s["member_count"]} for s in snapshots[::step]]
|
|
if snapshots and (not growth or growth[-1]["t"] != snapshots[-1]["timestamp"]):
|
|
growth.append({"t": snapshots[-1]["timestamp"], "c": snapshots[-1]["member_count"]})
|
|
|
|
cutoff_48h = now - timedelta(hours=48)
|
|
hourly_48h = []
|
|
for k in sorted(hourly.keys()):
|
|
try:
|
|
ts = datetime.fromisoformat(k).replace(tzinfo=timezone.utc)
|
|
except Exception:
|
|
continue
|
|
if ts >= cutoff_48h:
|
|
hourly_48h.append({"h": k, "c": hourly[k].get("total", 0)})
|
|
|
|
channels = data.get("channels", {})
|
|
top_channels = sorted(
|
|
[{"name": v.get("name", "?"), "total": v.get("total_messages", 0)} for v in channels.values()],
|
|
key=lambda x: -x["total"]
|
|
)[:10]
|
|
|
|
users = data.get("user_stats", {})
|
|
top_users = sorted(
|
|
[{"username": u.get("username", "?"), "total": u.get("total_messages", 0), "last": u.get("last_message", "")}
|
|
for u in users.values()],
|
|
key=lambda x: -x["total"]
|
|
)[:10]
|
|
|
|
member_events = list(reversed(data.get("member_events", [])))[:25]
|
|
|
|
links = []
|
|
for discord_id, info in discord_links.items():
|
|
if not isinstance(info, dict):
|
|
continue
|
|
pid = info.get("profile_id")
|
|
profile = db.get_profile(pid) if pid else None
|
|
links.append({
|
|
"discord_id": discord_id,
|
|
"discord_username": info.get("username", "?"),
|
|
"linked_at": info.get("linked_at", ""),
|
|
"profile_id": pid,
|
|
"game_username": profile.get("Username", "?") if profile else "?",
|
|
"level": profile.get("Level", 0) if profile else 0,
|
|
})
|
|
|
|
ch_hours = _dd(float)
|
|
for s in voice_sessions:
|
|
ch_hours[s.get("channel_name", "?")] += s.get("duration_minutes", 0) / 60
|
|
top_voice = sorted(
|
|
[{"name": k, "hours": round(v, 1)} for k, v in ch_hours.items()],
|
|
key=lambda x: -x["hours"]
|
|
)[:8]
|
|
|
|
return jsonify({
|
|
"summary": summary,
|
|
"growth": growth,
|
|
"hourly_48h": hourly_48h,
|
|
"top_channels": top_channels,
|
|
"top_users": top_users,
|
|
"member_events": member_events,
|
|
"discord_links": links,
|
|
"top_voice": top_voice,
|
|
})
|
|
|
|
|
|
_VIDEOS_DIR = os.path.join(os.path.dirname(__file__), "..", "Videos")
|
|
_VIDEO_EXTS = {".mp4", ".webm", ".mov", ".avi", ".mkv", ".m4v"}
|
|
_MAX_VIDEO_BYTES = 512 * 1024 * 1024
|
|
|
|
|
|
@bp.route("/admin/videos")
|
|
@require_admin_api
|
|
def admin_videos_page(account, scopes):
|
|
return render_template("admin/videos.html", scopes=scopes, SCOPE_ADMIN=SCOPE_ADMIN)
|
|
|
|
|
|
@bp.route("/admin/api/videos")
|
|
@require_admin_api
|
|
def api_videos_list(account, scopes):
|
|
vdir = os.path.normpath(_VIDEOS_DIR)
|
|
files = []
|
|
if os.path.isdir(vdir):
|
|
for name in sorted(os.listdir(vdir)):
|
|
ext = os.path.splitext(name)[1].lower()
|
|
if ext in _VIDEO_EXTS:
|
|
path = os.path.join(vdir, name)
|
|
files.append({"name": name, "size": os.path.getsize(path), "url": "/Videos/" + name})
|
|
return jsonify(files)
|
|
|
|
|
|
@bp.route("/admin/api/videos/replace", methods=["POST"])
|
|
@require_scope(SCOPE_ADMIN)
|
|
def api_videos_replace(account, scopes):
|
|
vdir = os.path.normpath(_VIDEOS_DIR)
|
|
target = os.path.basename(request.form.get("target_name", "") or (request.get_json(force=True, silent=True) or {}).get("target_name", ""))
|
|
if not target:
|
|
return jsonify({"error": "No target filename"}), 400
|
|
ext = os.path.splitext(target)[1].lower()
|
|
if ext not in _VIDEO_EXTS:
|
|
return jsonify({"error": "Invalid file type"}), 400
|
|
dest = os.path.join(vdir, target)
|
|
if not os.path.isfile(dest):
|
|
return jsonify({"error": "Target does not exist — only replacement of existing videos allowed"}), 400
|
|
url = request.form.get("url", "").strip()
|
|
f = request.files.get("file")
|
|
if url:
|
|
try:
|
|
with urllib.request.urlopen(url, timeout=60) as resp:
|
|
data = resp.read(_MAX_VIDEO_BYTES)
|
|
with open(dest, "wb") as out:
|
|
out.write(data)
|
|
except Exception as e:
|
|
return jsonify({"error": f"URL fetch failed: {e}"}), 400
|
|
elif f and f.filename:
|
|
f.save(dest)
|
|
else:
|
|
return jsonify({"error": "Provide a file or URL"}), 400
|
|
size = os.path.getsize(dest)
|
|
admin = account.get("username", "admin")
|
|
ip = request.headers.get("X-Forwarded-For", request.remote_addr or "")
|
|
db.log_admin_action(admin, "video_replace", f"Replaced video: {target} ({size} bytes)", ip)
|
|
return jsonify({"ok": True, "name": target, "size": size, "url": "/Videos/" + target})
|
|
|
|
|
|
@bp.route("/admin/api/videos/delete", methods=["POST"])
|
|
@require_scope(SCOPE_ADMIN)
|
|
def api_videos_delete(account, scopes):
|
|
data = request.get_json(force=True, silent=True) or {}
|
|
name = os.path.basename(data.get("name", ""))
|
|
if not name:
|
|
return jsonify({"error": "No filename"}), 400
|
|
ext = os.path.splitext(name)[1].lower()
|
|
if ext not in _VIDEO_EXTS:
|
|
return jsonify({"error": "Invalid file type"}), 400
|
|
vdir = os.path.normpath(_VIDEOS_DIR)
|
|
path = os.path.join(vdir, name)
|
|
if not os.path.isfile(path):
|
|
return jsonify({"error": "Not found"}), 404
|
|
os.remove(path)
|
|
admin = account.get("username", "admin")
|
|
ip = request.headers.get("X-Forwarded-For", request.remote_addr or "")
|
|
db.log_admin_action(admin, "video_delete", f"Deleted video: {name}", ip)
|
|
return jsonify({"ok": True})
|
|
|
|
|
|
@bp.route("/admin/logout")
|
|
def admin_logout():
|
|
resp = redirect(make_login_redirect(f"{_base_url}/admin/"))
|
|
resp.set_cookie("Authorization", "", max_age=0, domain=_auth_cfg["cookie_domain"], path="/")
|
|
resp.set_cookie("Authorization", "", max_age=0, path="/")
|
|
session.pop("emergency_admin", None)
|
|
return resp
|
|
|
|
|
|
_EMERGENCY_HTML = """<!DOCTYPE html>
|
|
<html><head><title>kittyrec-admin login</title><style>
|
|
*{box-sizing:border-box;margin:0;padding:0}
|
|
html,body{height:100%;background:#0a0a0a;color:#33ff33;font-family:'Cascadia Code','Fira Code','SF Mono',monospace;font-size:14px;line-height:1.6}
|
|
body{display:flex;align-items:center;justify-content:center}
|
|
.term{width:600px;background:#0a0a0a;border:1px solid #1a1a1a;border-radius:4px;overflow:hidden;box-shadow:0 0 40px rgba(0,255,0,0.07)}
|
|
.term-bar{background:#151515;padding:10px 16px;display:flex;align-items:center;gap:8px;border-bottom:1px solid #1a1a1a}
|
|
.term-dot{width:12px;height:12px;border-radius:50%}
|
|
.term-dot.r{background:#ff5f56}.term-dot.y{background:#ffbd2e}.term-dot.g{background:#27c93f}
|
|
.term-title{flex:1;text-align:center;font-size:12px;color:#444;letter-spacing:0.05em}
|
|
.term-body{padding:24px 28px 28px}
|
|
.line{margin-bottom:2px;white-space:pre}
|
|
.prompt{color:#33ff33}
|
|
.cmd{color:#ffffff}
|
|
.comment{color:#444}
|
|
.warn{color:#ff4444}
|
|
.dim{color:#555}
|
|
.spacer{height:14px}
|
|
.input-line{display:flex;align-items:center;gap:0;margin-top:4px}
|
|
.input-line .prompt{white-space:pre;flex-shrink:0}
|
|
.pw-wrap{position:relative;flex:1}
|
|
.pw-wrap input{background:transparent;border:none;outline:none;color:#ffffff;font-family:inherit;font-size:14px;width:100%;caret-color:#33ff33;letter-spacing:0.1em}
|
|
.cursor{display:inline-block;width:8px;height:14px;background:#33ff33;animation:blink 1s step-end infinite;vertical-align:middle;margin-left:1px}
|
|
@keyframes blink{0%,100%{opacity:1}50%{opacity:0}}
|
|
.err-line{color:#ff4444;margin-top:6px}
|
|
button[type=submit]{display:none}
|
|
</style></head><body>
|
|
<div class="term">
|
|
<div class="term-bar">
|
|
<div class="term-dot r"></div><div class="term-dot y"></div><div class="term-dot g"></div>
|
|
<div class="term-title">kittyrec-admin — bash — 80x24</div>
|
|
</div>
|
|
<div class="term-body">
|
|
<div class="line dim"># KittyRec Administrative Shell v2.0</div>
|
|
<div class="line dim"># Primary auth server unreachable — emergency mode active</div>
|
|
<div class="spacer"></div>
|
|
<div class="line"><span class="prompt">root@kittyrec</span><span class="cmd">:~# </span><span class="cmd">sudo adminctl auth --emergency</span></div>
|
|
<div class="line warn">[WARN] Auth server is unreachable</div>
|
|
<div class="line warn">[WARN] Falling back to emergency credential store</div>
|
|
<div class="spacer"></div>
|
|
<div class="line dim">Enter emergency passphrase to continue:</div>
|
|
<form method="POST" id="f">
|
|
<div class="input-line">
|
|
<span class="prompt">root@kittyrec</span><span class="cmd">:~# </span>
|
|
<div class="pw-wrap">
|
|
<input type="password" name="pw" id="pw" autocomplete="off" autofocus spellcheck="false">
|
|
</div>
|
|
</div>
|
|
<button type="submit"></button>
|
|
</form>
|
|
{error}
|
|
</div>
|
|
</div>
|
|
<script>
|
|
document.getElementById('pw').addEventListener('keydown',function(e){if(e.key==='Enter'){e.preventDefault();document.getElementById('f').submit();}});
|
|
</script>
|
|
</body></html>"""
|
|
|
|
|
|
@bp.route("/admin/emergency_login", methods=["GET", "POST"])
|
|
@limiter.limit("5 per minute")
|
|
def emergency_login():
|
|
import hmac
|
|
import time as _time
|
|
if not probe_auth_server():
|
|
return redirect("/admin/")
|
|
if request.method == "POST":
|
|
if hmac.compare_digest(request.form.get("pw", ""), EMERGENCY_PASSWORD):
|
|
session["emergency_admin"] = {"expires": _time.time() + _EMERGENCY_SESSION_TTL}
|
|
print("[Admin] Emergency login granted")
|
|
return redirect("/admin/")
|
|
html = _EMERGENCY_HTML.replace("{error}", '<div class="err-line">[ERR] Authentication failed: incorrect passphrase</div>')
|
|
return html, 200
|
|
return _EMERGENCY_HTML.replace("{error}", ""), 200
|
|
|
|
|
|
def register_console_ws(sock):
|
|
@sock.route("/admin/ws/console")
|
|
def console_ws(ws):
|
|
account, scopes = _get_admin_account()
|
|
if not account or not _has_any_admin_scope(scopes):
|
|
ws.close()
|
|
return
|
|
|
|
pos = 0
|
|
try:
|
|
with open(_LOG_PATH, "rb") as f:
|
|
f.seek(0, 2)
|
|
size = f.tell()
|
|
start = max(0, size - _LOG_INITIAL_BYTES)
|
|
f.seek(start)
|
|
chunk = f.read()
|
|
pos = size
|
|
if chunk:
|
|
ws.send(chunk.decode("utf-8", errors="replace"))
|
|
except FileNotFoundError:
|
|
pass
|
|
|
|
while True:
|
|
try:
|
|
time.sleep(0.2)
|
|
with open(_LOG_PATH, "rb") as f:
|
|
f.seek(0, 2)
|
|
new_size = f.tell()
|
|
if new_size > pos:
|
|
with open(_LOG_PATH, "rb") as f:
|
|
f.seek(pos)
|
|
chunk = f.read(new_size - pos)
|
|
pos = new_size
|
|
if chunk:
|
|
ws.send(chunk.decode("utf-8", errors="replace"))
|
|
elif new_size < pos:
|
|
pos = new_size
|
|
except Exception:
|
|
break
|