Upload files to "routes"

This commit is contained in:
2026-07-24 15:34:40 +00:00
parent 2ca832a741
commit 1b073dcfa3
5 changed files with 1651 additions and 0 deletions

272
routes/ws.py Normal file
View File

@@ -0,0 +1,272 @@
import json
import threading
from core.state import db, session_mgr, ws_registry
from core.ws_helpers import push_presence, push_gift
from core.builders import activity_info
from core.ban_service import cascade_kick_linked, kick_player
from core.constants import DORM_ROOM_GUID
from core.config import server as _server_cfg, base_url as _base_url
SERVER_BUILD = _server_cfg.get("build", "")
_next_session_id = 1
_session_lock = threading.Lock()
def _is_ip_banned(ip: str) -> bool:
return db.is_ip_banned(ip)
def register_ws(sock) -> None:
@sock.route("/api/notification/v2")
def notification_ws(ws):
global _next_session_id
from core.auth import get_current_profile_id
from flask import request as ws_req
pid = get_current_profile_id()
if pid is None:
print("[WS] Rejected unauthenticated WebSocket connection")
ws.close()
return
ip = (ws_req.headers.get("X-Forwarded-For", "") or ws_req.remote_addr or "").split(",")[0].strip()
if ip and ip not in ("127.0.0.1", "::1"):
db.record_ip_login(pid, ip)
if db.is_banned(pid):
print(f"[WS] Banned player {pid} tried to connect — closing")
cascade_kick_linked(pid)
try:
ws.send(json.dumps({"Id": 20, "Msg": {}}))
except Exception:
pass
ws.close()
return
import core.state as _st
with _st.maintenance_lock:
maint = _st.maintenance_mode
if maint:
if pid not in _st.maintenance_exempt:
print(f"[WS] Player {pid} rejected during maintenance")
ws.close()
return
if _is_ip_banned(ip):
print(f"[WS] IP-banned address {ip} tried to connect (pid={pid}) — closing")
if not db.is_banned(pid):
db.ban_player(pid, reason="Banned by IP association", duration_hours=0, admin_name="AntiCheat")
print(f"[AntiCheat] IP cascade ban: player {pid} at banned IP {ip}")
cascade_kick_linked(pid)
try:
ws.send(json.dumps({"Id": 20, "Msg": {}}))
except Exception:
pass
ws.close()
return
try:
handshake_raw = ws.receive()
if handshake_raw is None:
print(f"[WS] Player {pid}: connection closed before handshake")
return
handshake = json.loads(handshake_raw)
print(f"[WS] Player {pid} connected (keys: {list(handshake.keys())})")
except Exception as e:
print(f"[WS] Bad handshake from player {pid}: {e}")
return
with _session_lock:
ws_session_id = _next_session_id
_next_session_id += 1
ws.send(json.dumps({"SessionId": ws_session_id}))
ws_registry.register(pid, ws)
from core.daemons import record_session_start
record_session_start(pid)
for pending in db.get_pending_gifts(pid):
try:
push_gift(pid, pending)
except Exception:
pass
from core.daemons import record_heartbeat
record_heartbeat(pid)
settings = db.get_settings(pid)
if any(s["Key"] == "screen_mode_user" and s["Value"] == "1" for s in settings):
ws_registry.set_screen_mode(pid, True)
try:
from core.discord import mark_first_login, send_public
if mark_first_login(pid):
p = db.get_profile(pid)
uname = p["Username"] if p else str(pid)
dname = (p or {}).get("DisplayName", uname)
img = (p or {}).get("ProfileImageName", "")
send_public(
title="First Login!",
color=0x3498DB,
fields=[{"name": "Player", "value": uname, "inline": True},
{"name": "ID", "value": str(pid), "inline": True}],
description=f"**{dname}** just logged in for the very first time!",
thumbnail_url=f"{_base_url}/alt/{img}" if img else None,
throttle_key=f"firstlogin_{pid}",
throttle_secs=0,
)
except Exception:
pass
session = session_mgr.get_player_session(pid)
if session is None:
name, key, sandbox = activity_info(DORM_ROOM_GUID)
session = session_mgr.join_room(pid, DORM_ROOM_GUID, name, key,
private=True, sandbox=sandbox)
push_presence(pid, session)
for other_pid in ws_registry.connected_ids():
if other_pid == pid:
continue
other_session = session_mgr.get_player_session(other_pid)
try:
ws.send(json.dumps({
"Id": 12,
"Msg": {
"PlayerId": other_pid,
"IsOnline": True,
"InScreenMode": ws_registry.is_screen_mode(other_pid),
"GameSession": other_session.to_dict() if other_session else None,
},
}))
except Exception:
pass
from core.state import _KITTYREC_SYSTEM_PID
try:
ws.send(json.dumps({
"Id": 12,
"Msg": {
"PlayerId": _KITTYREC_SYSTEM_PID,
"IsOnline": True,
"InScreenMode": True,
"GameSession": None,
},
}))
except Exception:
pass
print(f"[WS] Player {pid} → '{session.name}' "
f"(sid={session.session_id}, {len(session.players)} in room, "
f"{ws_registry.player_count()} online)")
from tracking.password_tracking import has_real_password
if not has_real_password(pid):
def _send_pw_msg(_pid=pid):
import time, string, random
from core.state import _KITTYREC_SYSTEM_PID
from datetime import datetime, timezone
time.sleep(10)
if not ws_registry.is_connected(_pid):
return
if has_real_password(_pid):
return
temp_pw = "".join(random.choices(string.ascii_letters + string.digits, k=8))
_c = db._get_conn()
_c.execute(
"UPDATE profiles SET password = ? WHERE id = ? AND registration_status != 2",
(temp_pw, _pid),
)
_c.commit()
profile = db.get_profile(_pid)
uname = profile["Username"] if profile else f"Player {_pid}"
msg_text = (
f"Welcome to KittyRec!\n"
f"Username: {uname}\n"
f"Temp password: {temp_pw}\n"
f"STOP SHARING YOUR SCREEN!\n"
f"Reply to this message with a new password (8+ chars) to register!"
)
msg_type = 30
db.delete_messages_of_type(_pid, _KITTYREC_SYSTEM_PID, msg_type)
msg_id = db.send_message(_KITTYREC_SYSTEM_PID, _pid, msg_type, msg_text)
sent = datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
ws_registry.send(_pid, {"Id": 2, "Msg": {
"Id": msg_id, "FromPlayerId": _KITTYREC_SYSTEM_PID,
"SentTime": sent, "Type": msg_type, "Data": msg_text,
"RoomId": None, "PlayerEventId": None,
}})
print(f"[System] Sent temp password to pid={_pid} user={uname}")
threading.Thread(target=_send_pw_msg, daemon=True, name=f"temp-pw-{pid}").start()
try:
while True:
msg = ws.receive()
if msg is None:
break
try:
data = json.loads(msg)
api = data.get("api", "")
if api == "heartbeat2":
record_heartbeat(pid)
cur = session_mgr.get_player_session(pid) or session
param = data.get("param") or {}
client_gm = param.get("SpecialGamemode")
if client_gm is not None and cur:
try:
session_mgr.modify_session(cur.session_id, special_gamemode=int(client_gm))
except Exception:
pass
ws.send(json.dumps({
"Id": 4,
"Msg": {
"PlayerId": pid,
"IsOnline": True,
"InScreenMode": ws_registry.is_screen_mode(pid),
"GameSession": cur.to_dict(),
},
}))
elif api == "playerSubscriptions/v1/update":
param = data.get("param", {}) or {}
sub_ids = param.get("PlayerIds", param.get("playerIds", []))[:200]
for sub_pid in sub_ids:
sub_session = session_mgr.get_player_session(sub_pid)
ws.send(json.dumps({
"Id": 12,
"Msg": {
"PlayerId": sub_pid,
"IsOnline": ws_registry.is_connected(sub_pid),
"InScreenMode": ws_registry.is_screen_mode(sub_pid),
"GameSession": sub_session.to_dict() if sub_session else None,
},
}))
else:
print(f"[WS] Player {pid}: unhandled api={api!r} data={data}")
except json.JSONDecodeError:
pass
except Exception as e:
print(f"[WS] Player {pid} error: {e}")
finally:
removed = ws_registry.unregister(pid, ws)
if removed:
from core.daemons import flush_session_time
flush_session_time(pid)
session_mgr.leave_session(pid)
push_presence(pid, None, online=False)
from routes.sessions import session_gift_reset
session_gift_reset(pid)
print(f"[WS] Player {pid} disconnected – "
f"{ws_registry.player_count()} remaining")
else:
print(f"[WS] Player {pid} old socket closed "
f"(new connection already registered – ignoring cleanup)")