import base64 as _wolf_b64 def _wolf_s(_wolf_e): _wolf_x = bytearray(_wolf_b64.b64decode(_wolf_e)) for _wolf_i in range(len(_wolf_x)): _wolf_x[_wolf_i] ^= 90 return bytes(_wolf_x).decode('utf-8') import base64 import hashlib import json import os import re import shutil import socket import subprocess import sys import tempfile import threading import time from urllib.parse import quote try: import spaces except Exception: spaces = None try: import gradio as gr except Exception: gr = None from functools import wraps import psutil import requests as http from flask import Flask, g, jsonify, make_response, redirect, request, send_from_directory import gwclient from gwclient import verify_gateway_headers PROBE_PORT = int(os.environ.get(_wolf_s('CggVGB8FChUIDg=='), _wolf_s('bWJsaw=='))) if spaces is not None: @spaces.GPU(duration=1) def _noop_gpu_slot() -> str: return _wolf_s('NTE=') else: def _noop_gpu_slot() -> str: return _wolf_s('NTE=') def _start_zerogpu_probe(): if spaces is None or gr is None: print(_wolf_s('ASA/KDU9Ki93Kig1OD8HeikxMyoqPz56cikqOzk/KXU9KDs+MzV6NDUuejssOzM2Ozg2P3M='), flush=True) return try: with gr.Blocks(title=_wolf_s('DTU2PHoSNSkuerjaznoAPyg1HQoPeiooNTg/')) as probe: gr.Markdown(_wolf_s('EzQuPyg0OzZ6AD8oNR0KD3opLjsoLi8qeiooNTg/erjaznouMj96Kjs0PzZ6NjMsPyl6Oy56OnU6dA==')) btn = gr.Button(_wolf_s('Cig1OD96HQoPeik2NS4=')) txt = gr.Textbox(label=_wolf_s('CD8pLzYu')) btn.click(fn=_noop_gpu_slot, inputs=[], outputs=[txt]) probe.launch(server_name=_wolf_s('a2htdGp0anRr'), server_port=PROBE_PORT, prevent_thread_lock=True, quiet=True, share=False, show_error=False) print(f'[zerogpu-probe] Gradio probe up on 127.0.0.1:{PROBE_PORT}', flush=True) except Exception as e: print(f'[zerogpu-probe] FAILED: {e}', flush=True) def _wait_for_port(port: int, timeout: float=15.0) -> bool: deadline = time.time() + timeout while time.time() < deadline: try: with socket.create_connection((_wolf_s('a2htdGp0anRr'), port), timeout=0.5): return True except OSError: time.sleep(0.2) return False BASE_DIR = os.path.dirname(os.path.abspath(__file__)) SECURE_ROOT = os.path.abspath(BASE_DIR) USERS_ROOT = os.path.join(SECURE_ROOT, _wolf_s('DwkfCAk=')) DATA_DIR = os.path.join(SECURE_ROOT, _wolf_s('HhsOGw==')) USERS_DB = os.path.join(DATA_DIR, _wolf_s('Lyk/KCl0MCk1NA==')) os.makedirs(USERS_ROOT, exist_ok=True) os.makedirs(DATA_DIR, exist_ok=True) app = Flask(__name__) _ON_SPACES = bool(os.environ.get(_wolf_s('CQobGR8FEx4=')) or os.environ.get(_wolf_s('CQobGR8JBQAfCBUFHQoP'))) REGISTRATION_ENABLED = os.environ.get(_wolf_s('GxYWFQ0FCB8dEwkOCBsOExUU'), _wolf_s('ag==')) == _wolf_s('aw==') print(f"[panel-config] gateway={(_wolf_s('KT8u') if gwclient.GATEWAY_URL else _wolf_s('FxMJCRMUHQ=='))} secret={(_wolf_s('KT8u') if gwclient.SERVICE_SECRET else _wolf_s('FxMJCRMUHQ=='))} REGISTRATION_ENABLED={REGISTRATION_ENABLED}", flush=True) running_procs = {} server_states = {} lock = threading.Lock() _starting_keys = set() def is_path_safe(base_dir: str, target_path: str) -> bool: try: real_target = os.path.realpath(target_path) real_base = os.path.realpath(base_dir) common = os.path.commonpath([real_target, real_base]) return common == real_base except (ValueError, OSError): return False def secure_join(base_dir: str, *paths) -> str: base_dir = os.path.realpath(base_dir) current_path = base_dir for path in paths: parts = path.split(_wolf_s('dQ==')) for part in parts: if part == _wolf_s('dHQ='): raise ValueError(_wolf_s('CjsuMnouKDssPygpOzZ6Oy4uPzcqLno+Py4/OS4/Pg==')) elif part == _wolf_s('dA==') or part == _wolf_s(''): continue else: current_path = os.path.join(current_path, part) current_path = os.path.realpath(current_path) if not current_path.startswith(base_dir + os.sep) and current_path != base_dir: raise ValueError(_wolf_s('CT85LygzLiN6LDM1NjsuMzU0YHobLi4/NyouPz56LjV6Ozk5PykpejUvLikzPj96KT85Lyg/eig1NS4=')) return current_path def get_user_servers_root(username: str) -> str: safe_username = re.sub(_wolf_s('AQQ7dyAbdwBqd2MFdHcH'), _wolf_s(''), username) return os.path.join(USERS_ROOT, safe_username, _wolf_s('KT8oLD8oKQ==')) def get_server_dir(owner: str, folder: str) -> str: safe_owner = re.sub(_wolf_s('AQQ7dyAbdwBqd2MFdHcH'), _wolf_s(''), owner) safe_folder = re.sub(_wolf_s('AQQ7dyAbdwBqd2MFdHcH'), _wolf_s(''), folder) base = get_user_servers_root(safe_owner) return os.path.join(base, safe_folder) def ensure_user_dirs(username: str): try: path = get_user_servers_root(username) os.makedirs(path, exist_ok=True) except Exception as e: print(f'Security Alert: {e}') def parse_server_key(key: str, allow_admin: bool): key = (key or _wolf_s('')).strip() if _wolf_s('dHQ=') in key or key.startswith(_wolf_s('dQ==')) or key.startswith(_wolf_s('Bg==')): raise ValueError(_wolf_s('EzQsOzYzPnoxPyN6PDUoNzsu')) if _wolf_s('YGA=') in key: if not allow_admin or not is_admin_session(): raise ValueError(_wolf_s('PDUoODM+Pj80')) owner, folder = key.split(_wolf_s('YGA='), 1) owner = owner.strip() folder = folder.strip() if not re.match(_wolf_s('BAE7dyAbdwBqd2MFdHcHcX4='), owner) or not re.match(_wolf_s('BAE7dyAbdwBqd2MFdHcHcX4='), folder): raise ValueError(_wolf_s('EzQsOzYzPno5MjsoOzkuPygpejM0ejUtND8oejUoejw1Nj4/KA==')) return (owner, folder) if not is_admin_session(): username = current_username() if not re.match(_wolf_s('BAE7dyAbdwBqd2MFdHcHcX4='), username) or not re.match(_wolf_s('BAE7dyAbdwBqd2MFdHcHcX4='), key): raise ValueError(_wolf_s('EzQsOzYzPno5MjsoOzkuPygp')) return (username, key) else: return (current_username(), key) def can_access_key(key: str) -> bool: try: owner, folder = parse_server_key(key, allow_admin=True) except Exception: return False if is_admin_session(): return True return owner == current_username() def safe_join_server_path(key: str, rel_path: str=_wolf_s('')) -> str: try: owner, folder = parse_server_key(key, allow_admin=True) except Exception as e: raise ValueError(f'Invalid key: {e}') server_root = get_server_dir(owner, folder) if not os.path.exists(server_root): raise FileNotFoundError(f'Server directory not found: {server_root}') if not rel_path: return server_root rel_path = rel_path.lstrip(_wolf_s('dQY=')) if _wolf_s('dHQ=') in rel_path or rel_path.startswith(_wolf_s('dQ==')) or rel_path.startswith(_wolf_s('Bg==')): raise ValueError(_wolf_s('EzQsOzYzPnoqOy4y')) full_path = os.path.join(server_root, rel_path) full_path = os.path.realpath(full_path) if not full_path.startswith(server_root + os.sep) and full_path != server_root: raise ValueError(_wolf_s('CT85LygzLiN6LDM1NjsuMzU0')) return full_path def get_ip(): try: s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) s.connect((_wolf_s('a2p0aG9vdGhvb3Rob28='), 1)) ip = s.getsockname()[0] s.close() return ip except Exception: return _wolf_s('a2htdGp0anRr') def sanitize_folder_name(name: str) -> str: name = (name or _wolf_s('')).strip() name = re.sub(_wolf_s('Bilx'), _wolf_s('dw=='), name) name = re.sub(_wolf_s('AQQbdwA7dyBqd2MGdwUGdAc='), _wolf_s(''), name) return name[:200] def safe_name(name: str) -> str: name = (name or _wolf_s('')).strip() name = re.sub(_wolf_s('AQYGdQdx'), _wolf_s(''), name) name = re.sub(_wolf_s('AQQbdwA7dyBqd2MGdwUGdHoH'), _wolf_s(''), name) return name[:200].strip() SERVER_TYPES = (_wolf_s('KiMuMjU0'), _wolf_s('LT84Oyoq'), _wolf_s('Oyoz'), _wolf_s('KjIq')) _SUBDOMAIN_RE = re.compile(_wolf_s('BAE7dyBqd2MHcgE7dyBqd2N3ByFqdmliJwE7dyBqd2MHc2V+')) def normalize_subdomain(raw: str) -> str: raw = (raw or _wolf_s('')).strip().lower() raw = re.sub(_wolf_s('AQQ7dyBqd2N3Bw=='), _wolf_s('dw=='), raw) raw = re.sub(_wolf_s('dyFodic='), _wolf_s('dw=='), raw).strip(_wolf_s('dw==')) return raw[:40] def list_all_metas(): out = [] if not os.path.isdir(USERS_ROOT): return out for owner in sorted(os.listdir(USERS_ROOT)): servers_dir = os.path.join(USERS_ROOT, owner, _wolf_s('KT8oLD8oKQ==')) if not os.path.isdir(servers_dir): continue for folder in sorted(os.listdir(servers_dir)): try: out.append((owner, folder, read_meta(owner, folder))) except Exception: continue return out def subdomain_taken(sub: str, exclude=None) -> bool: for owner, folder, meta in list_all_metas(): if exclude and (owner, folder) == exclude: continue if (meta.get(_wolf_s('KS84PjU3OzM0')) or _wolf_s('')).lower() == sub: return True return False def find_server_by_subdomain(sub: str): sub = (sub or _wolf_s('')).strip().lower() if not sub: return None for owner, folder, meta in list_all_metas(): if (meta.get(_wolf_s('KS84PjU3OzM0')) or _wolf_s('')).lower() == sub: return (owner, folder, meta) return None def allocate_port() -> int: used = set() for _owner, _folder, meta in list_all_metas(): try: p = int(meta.get(_wolf_s('KjUoLg==')) or 0) except Exception: p = 0 if p: used.add(p) for port in range(8100, 8999): if port not in used: return port return 8100 def set_state(key: str, state: str): with lock: server_states[key] = state def get_state(key: str) -> str: with lock: return server_states.get(key, _wolf_s('FTw8NjM0Pw==')) def split_key(key: str): key = (key or _wolf_s('')).strip() if _wolf_s('YGA=') in key: owner, folder = key.split(_wolf_s('YGA='), 1) return (owner.strip(), folder.strip()) return (_wolf_s(''), key) def log_append(key: str, text: str): try: owner, folder = split_key(key) if not owner or not folder: return server_dir = get_server_dir(owner, folder) if not os.path.isdir(server_dir): return log_path = os.path.join(server_dir, _wolf_s('KT8oLD8odDY1PQ==')) with open(log_path, _wolf_s('Ow=='), encoding=_wolf_s('Ly48d2I='), errors=_wolf_s('Mz00NSg/')) as f: f.write(text) except Exception: pass def is_admin_session(): try: return bool(getattr(g, _wolf_s('Mz4/NC4zLiM='), {}).get(_wolf_s('MykFOz43MzQ='))) except Exception: return False def current_username(): try: return (getattr(g, _wolf_s('Mz4/NC4zLiM='), {}).get(_wolf_s('Lyk/KDQ7Nz8=')) or _wolf_s('')).strip() except Exception: return _wolf_s('') def get_user_limit(username: str) -> int: return 999999 PAGE_ROUTES = {_wolf_s('dQ=='), _wolf_s('dTs+NzM0'), _wolf_s('dTY1PTM0'), _wolf_s('dTkoPzsuPw==')} def _is_api_request(): return request.path not in PAGE_ROUTES @app.before_request def _trust_gateway_only(): g.identity = verify_gateway_headers(request.method, request.path, request.headers) def login_required(fn): @wraps(fn) def wrapper(*args, **kwargs): if not getattr(g, _wolf_s('Mz4/NC4zLiM='), {}).get(_wolf_s('Lyk/KDQ7Nz8=')): if _is_api_request(): return (jsonify({_wolf_s('KS85OT8pKQ=='): False, _wolf_s('Nz8pKTs9Pw=='): _wolf_s('Gy8uMj80LjM5Oy4zNTR6KD8rLzMoPz4=')}), 401) return redirect(_wolf_s('dTY1PTM0')) return fn(*args, **kwargs) return wrapper def admin_required(fn): @wraps(fn) def wrapper(*args, **kwargs): ident = getattr(g, _wolf_s('Mz4/NC4zLiM='), {}) if not ident.get(_wolf_s('Lyk/KDQ7Nz8=')): if _is_api_request(): return (jsonify({_wolf_s('KS85OT8pKQ=='): False, _wolf_s('Nz8pKTs9Pw=='): _wolf_s('Gy8uMj80LjM5Oy4zNTR6KD8rLzMoPz4=')}), 401) return redirect(_wolf_s('dTY1PTM0')) if not ident.get(_wolf_s('MykFOz43MzQ=')): return (jsonify({_wolf_s('KS85OT8pKQ=='): False, _wolf_s('Nz8pKTs9Pw=='): _wolf_s('Gz43MzR6NTQ2Iw==')}), 403) return fn(*args, **kwargs) return wrapper def ensure_meta(owner: str, folder: str): server_dir = get_server_dir(owner, folder) os.makedirs(server_dir, exist_ok=True) meta_path = os.path.join(server_dir, _wolf_s('Nz8uO3QwKTU0')) base = {_wolf_s('PjMpKjY7IwU0Ozc/'): folder, _wolf_s('KS47KC4vKgU8MzY/'): _wolf_s(''), _wolf_s('NS00Pyg='): owner, _wolf_s('ODs0ND8+'): False, _wolf_s('LiMqPw=='): _wolf_s('KiMuMjU0'), _wolf_s('KS84PjU3OzM0'): _wolf_s(''), _wolf_s('KjUoLg=='): 0} if not os.path.exists(meta_path): with open(meta_path, _wolf_s('LQ=='), encoding=_wolf_s('Ly48d2I=')) as f: json.dump(base, f, indent=2) else: try: with open(meta_path, _wolf_s('KA=='), encoding=_wolf_s('Ly48d2I=')) as f: m = json.load(f) or {} except Exception: m = {} changed = False for k, v in base.items(): if k not in m: m[k] = v changed = True if m.get(_wolf_s('NS00Pyg=')) != owner: m[_wolf_s('NS00Pyg=')] = owner changed = True if changed: with open(meta_path, _wolf_s('LQ=='), encoding=_wolf_s('Ly48d2I=')) as f: json.dump(m, f, indent=2) return meta_path def read_meta(owner: str, folder: str): meta_path = ensure_meta(owner, folder) try: with open(meta_path, _wolf_s('KA=='), encoding=_wolf_s('Ly48d2I=')) as f: return json.load(f) or {} except Exception: return {_wolf_s('PjMpKjY7IwU0Ozc/'): folder, _wolf_s('KS47KC4vKgU8MzY/'): _wolf_s(''), _wolf_s('NS00Pyg='): owner, _wolf_s('ODs0ND8+'): False, _wolf_s('LiMqPw=='): _wolf_s('KiMuMjU0'), _wolf_s('KS84PjU3OzM0'): _wolf_s(''), _wolf_s('KjUoLg=='): 0} def write_meta(owner: str, folder: str, meta): meta_path = ensure_meta(owner, folder) with open(meta_path, _wolf_s('LQ=='), encoding=_wolf_s('Ly48d2I=')) as f: json.dump(meta, f, indent=2) gwclient.push_meta(owner, folder, meta) def sha256_file(path): h = hashlib.sha256() with open(path, _wolf_s('KDg=')) as f: for chunk in iter(lambda: f.read(1024 * 1024), b''): h.update(chunk) return h.hexdigest() def installed_file_path(owner: str, folder: str): return os.path.join(get_server_dir(owner, folder), _wolf_s('dDM0KS47NjY/Pg==')) def read_installed(owner: str, folder: str): p = installed_file_path(owner, folder) data = {_wolf_s('KD8rBSkyOw=='): _wolf_s(''), _wolf_s('KjE9KQ=='): set()} if not os.path.exists(p): return data try: with open(p, _wolf_s('KA=='), encoding=_wolf_s('Ly48d2I='), errors=_wolf_s('Mz00NSg/')) as f: for line in f.read().splitlines(): line = line.strip() if not line: continue if line.startswith(_wolf_s('CB8LBQkSG2c=')): data[_wolf_s('KD8rBSkyOw==')] = line.split(_wolf_s('Zw=='), 1)[1].strip() else: data[_wolf_s('KjE9KQ==')].add(line) except Exception: pass return data def write_installed(owner: str, folder: str, req_sha=None, add_pkgs=None): p = installed_file_path(owner, folder) cur = read_installed(owner, folder) if req_sha is not None: cur[_wolf_s('KD8rBSkyOw==')] = req_sha if add_pkgs: cur[_wolf_s('KjE9KQ==')].update(add_pkgs) lines = [] if cur[_wolf_s('KD8rBSkyOw==')]: lines.append(f"REQ_SHA={cur[_wolf_s('KD8rBSkyOw==')]}") lines.extend(sorted(cur[_wolf_s('KjE9KQ==')])) with open(p, _wolf_s('LQ=='), encoding=_wolf_s('Ly48d2I=')) as f: f.write(_wolf_s('UA==').join(lines) + (_wolf_s('UA==') if lines else _wolf_s(''))) def ensure_requirements_installed(owner: str, folder: str): server_dir = get_server_dir(owner, folder) req_path = os.path.join(server_dir, _wolf_s('KD8rLzMoPzc/NC4pdC4iLg==')) if not os.path.exists(req_path): return False req_sha = sha256_file(req_path) cur = read_installed(owner, folder) stamp = os.path.join(tempfile.gettempdir(), _wolf_s('dC01NjwFKD8rBQ==') + hashlib.sha256(f'{owner}::{folder}'.encode()).hexdigest()[:24]) installed_here = False try: with open(stamp, _wolf_s('KA=='), encoding=_wolf_s('Ly48d2I=')) as f: installed_here = f.read().strip() == req_sha except OSError: pass if installed_here and cur[_wolf_s('KD8rBSkyOw==')] == req_sha: return False log_append(f'{owner}::{folder}', _wolf_s('AQkDCQ4fFwd6EzQpLjs2NjM0PXooPysvMyg/Nz80Lil0LiIudHR0UA==')) try: log_path = os.path.join(server_dir, _wolf_s('KT8oLD8odDY1PQ==')) with open(log_path, _wolf_s('Ow=='), encoding=_wolf_s('Ly48d2I='), errors=_wolf_s('Mz00NSg/')) as lf: subprocess.check_call([sys.executable, _wolf_s('dzc='), _wolf_s('KjMq'), _wolf_s('MzQpLjs2Ng=='), _wolf_s('d3cvKj0oOz4/'), _wolf_s('d3c0NXc5OzkyP3c+Myg='), _wolf_s('dyg='), _wolf_s('KD8rLzMoPzc/NC4pdC4iLg==')], cwd=server_dir, stdout=lf, stderr=subprocess.STDOUT) write_installed(owner, folder, req_sha=req_sha) try: with open(stamp, _wolf_s('LQ=='), encoding=_wolf_s('Ly48d2I=')) as f: f.write(req_sha) except OSError: pass log_append(f'{owner}::{folder}', _wolf_s('AQkDCQ4fFwd6CD8rLzMoPzc/NC4pejM0KS47NjY/PlA=')) return True except subprocess.CalledProcessError as e: log_append(f'{owner}::{folder}', f'[SYSTEM] Requirements install failed: {e}\n') return False def start_with_autoinstall(owner: str, folder: str, startup_file: str): proxy_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), _wolf_s('Kig1IiM=')) wrapper_code = _wolf_s('UDM3KjUoLnopIyl2ejUpdnooLzQqI3Z6KS84Kig1OT8pKXZ6Lig7OT84OzkxdnooP1ApIyl0KjsuMnQzNCk/KC5yanZ6KHg=') + proxy_dir + _wolf_s('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') server_dir = get_server_dir(owner, folder) log_path = os.path.join(server_dir, _wolf_s('KT8oLD8odDY1PQ==')) log_file = open(log_path, _wolf_s('Ow=='), encoding=_wolf_s('Ly48d2I='), errors=_wolf_s('Mz00NSg/')) env = os.environ.copy() meta = read_meta(owner, folder) server_type = (meta.get(_wolf_s('LiMqPw==')) or _wolf_s('KiMuMjU0')).lower() port = int(meta.get(_wolf_s('KjUoLg==')) or 0) or allocate_port() if not meta.get(_wolf_s('KjUoLg==')) and server_type in (_wolf_s('LT84Oyoq'), _wolf_s('Oyoz'), _wolf_s('KjIq')): meta[_wolf_s('KjUoLg==')] = port write_meta(owner, folder, meta) env.setdefault(_wolf_s('Dh8WHx0IGxcFCggVAgM='), _wolf_s('Mi4uKilgdXVpNzJ3MjUpLnQqOz0/KXQ+Pyx1Lj0=')) env.setdefault(_wolf_s('Dh8WHx0IGxcFCggVAgMFHBsWFhgbGRE='), _wolf_s('aw==')) env.setdefault(_wolf_s('CggVAgMFCR8ZCB8O'), _wolf_s('')) if server_type == _wolf_s('KjIq') or startup_file.lower().endswith(_wolf_s('dCoyKg==')): cmd = [_wolf_s('KjIq'), _wolf_s('dz4='), _wolf_s('PjMpKjY7IwU/KCg1KClnaw=='), _wolf_s('dwk='), f'127.0.0.1:{port}', _wolf_s('dy4='), server_dir] if startup_file and os.path.exists(os.path.join(server_dir, startup_file)): cmd.append(startup_file) try: proc = subprocess.Popen(cmd, cwd=server_dir, env=env, stdout=log_file, stderr=log_file) except FileNotFoundError: log_file.write(_wolf_s('AQkDCQ4fFwd6fSoyKn16ODM0OygjejQ1Lno8NS80Pnq42s56Myl6ChIKejM0KS47NjY/PnozNHouMjMpejM3Oz0/ZVA=')) log_file.close() raise RuntimeError(_wolf_s('KjIqejgzNDsoI3o3MykpMzQ9')) return (proc, log_file) if server_type in (_wolf_s('LT84Oyoq'), _wolf_s('Oyoz')): env.setdefault(_wolf_s('ChUIDg=='), str(port)) env.setdefault(_wolf_s('EhUJDg=='), _wolf_s('anRqdGp0ag==')) proc = subprocess.Popen([sys.executable, _wolf_s('dy8='), _wolf_s('dzk='), wrapper_code, startup_file], cwd=server_dir, env=env, stdout=log_file, stderr=log_file) return (proc, log_file) def stop_proc(key: str): if key in running_procs: proc, logf = running_procs[key] try: p = psutil.Process(proc.pid) for child in p.children(recursive=True): child.kill() p.kill() except Exception: pass try: logf.close() except Exception: pass running_procs.pop(key, None) @app.route(_wolf_s('dQ==')) @login_required def home(): return send_from_directory(BASE_DIR, _wolf_s('MzQ+PyJ0Mi43Ng==')) @app.route(_wolf_s('dTY1PTM0')) def login_page(): return send_from_directory(BASE_DIR, _wolf_s('NjU9MzR0Mi43Ng==')) @app.route(_wolf_s('dT41OSk=')) @login_required def docs_page(): return send_from_directory(BASE_DIR, _wolf_s('PjU5KXQyLjc2')) @app.route(_wolf_s('dTY1PTV0KjQ9')) def logo_img(): resp = make_response(send_from_directory(BASE_DIR, _wolf_s('NjU9NXQqND0='))) resp.headers[_wolf_s('GTs5Mj93GTU0Lig1Ng==')] = _wolf_s('Ki84NjM5dno3OyJ3Oz0/Z2Jsbmpq') return resp @app.route(_wolf_s('dTkoPzsuPw==')) def create_page(): if not REGISTRATION_ENABLED: return redirect(_wolf_s('dTY1PTM0')) return send_from_directory(BASE_DIR, _wolf_s('OSg/Oy4/dDIuNzY=')) @app.route(_wolf_s('dTs+NzM0')) @login_required def admin_page(): if not is_admin_session(): return redirect(_wolf_s('dQ==')) return send_from_directory(BASE_DIR, _wolf_s('Oz43MzR0Mi43Ng==')) def list_all_servers_for_admin(): servers = [] if not os.path.isdir(USERS_ROOT): return servers for owner in sorted(os.listdir(USERS_ROOT)): root = get_user_servers_root(owner) if not os.path.isdir(root): continue for folder in sorted(os.listdir(root)): server_dir = get_server_dir(owner, folder) if not os.path.isdir(server_dir): continue meta = read_meta(owner, folder) banned = bool(meta.get(_wolf_s('ODs0ND8+'), False)) key = f'{owner}::{folder}' st = _wolf_s('GDs0ND8+') if banned else get_state(key) servers.append({_wolf_s('LjMuNj8='): meta.get(_wolf_s('PjMpKjY7IwU0Ozc/'), folder), _wolf_s('PDU2Pj8o'): folder, _wolf_s('NS00Pyg='): owner, _wolf_s('MT8j'): key, _wolf_s('KS84LjMuNj8='): f'Owner: {owner}', _wolf_s('KS47KC4vKgU8MzY/'): meta.get(_wolf_s('KS47KC4vKgU8MzY/'), _wolf_s('')), _wolf_s('LiMqPw=='): meta.get(_wolf_s('LiMqPw=='), _wolf_s('KiMuMjU0')), _wolf_s('KS84PjU3OzM0'): meta.get(_wolf_s('KS84PjU3OzM0'), _wolf_s('')), _wolf_s('KTMuPwUvKDY='): _site_url_for(owner, folder, meta), _wolf_s('LT84MjU1MQ=='): bool(meta.get(_wolf_s('LT84MjU1MQ=='))), _wolf_s('KS47Li8p'): st}) return servers def list_servers_for_user(username: str): ensure_user_dirs(username) root = get_user_servers_root(username) servers = [] if not os.path.isdir(root): return servers for folder in sorted(os.listdir(root)): server_dir = get_server_dir(username, folder) if not os.path.isdir(server_dir): continue meta = read_meta(username, folder) banned = bool(meta.get(_wolf_s('ODs0ND8+'), False)) key = folder st = _wolf_s('GDs0ND8+') if banned else get_state(key) servers.append({_wolf_s('LjMuNj8='): meta.get(_wolf_s('PjMpKjY7IwU0Ozc/'), folder), _wolf_s('PDU2Pj8o'): folder, _wolf_s('NS00Pyg='): username, _wolf_s('MT8j'): key, _wolf_s('KS84LjMuNj8='): f'Owner: {username}', _wolf_s('KS47KC4vKgU8MzY/'): meta.get(_wolf_s('KS47KC4vKgU8MzY/'), _wolf_s('')), _wolf_s('LiMqPw=='): meta.get(_wolf_s('LiMqPw=='), _wolf_s('KiMuMjU0')), _wolf_s('KS84PjU3OzM0'): meta.get(_wolf_s('KS84PjU3OzM0'), _wolf_s('')), _wolf_s('KTMuPwUvKDY='): _site_url_for(username, folder, meta), _wolf_s('LT84MjU1MQ=='): bool(meta.get(_wolf_s('LT84MjU1MQ=='))), _wolf_s('KS47Li8p'): st}) return servers @app.route(_wolf_s('dSk/KCw/KCk=')) @login_required def servers(): admin = is_admin_session() if admin: return jsonify({_wolf_s('KS85OT8pKQ=='): True, _wolf_s('MykFOz43MzQ='): True, _wolf_s('KT8oLD8oKQ=='): list_all_servers_for_admin()}) return jsonify({_wolf_s('KS85OT8pKQ=='): True, _wolf_s('MykFOz43MzQ='): False, _wolf_s('KT8oLD8oKQ=='): list_servers_for_user(current_username())}) @app.route(_wolf_s('dTs+Pg=='), methods=[_wolf_s('ChUJDg==')]) @login_required def add_server(): data = request.get_json(silent=True) or {} name = (data.get(_wolf_s('NDs3Pw==')) or _wolf_s('')).strip() folder = sanitize_folder_name(name) if not folder: return (jsonify({_wolf_s('KS85OT8pKQ=='): False, _wolf_s('Nz8pKTs9Pw=='): _wolf_s('EzQsOzYzPnopPygsPyh6NDs3Pw==')}), 400) owner = current_username() server_type = (data.get(_wolf_s('LiMqPw==')) or _wolf_s('KiMuMjU0')).strip().lower() if server_type not in SERVER_TYPES: return (jsonify({_wolf_s('KS85OT8pKQ=='): False, _wolf_s('Nz8pKTs9Pw=='): f"Unknown type (allowed: {_wolf_s('dno=').join(SERVER_TYPES)})"}), 400) subdomain = normalize_subdomain(data.get(_wolf_s('KS84PjU3OzM0')) or _wolf_s('')) if server_type in (_wolf_s('LT84Oyoq'), _wolf_s('Oyoz'), _wolf_s('KjIq')): if not subdomain: subdomain = normalize_subdomain(folder) or _wolf_s('Oyoq') if not _SUBDOMAIN_RE.match(subdomain): return (jsonify({_wolf_s('KS85OT8pKQ=='): False, _wolf_s('Nz8pKTs9Pw=='): _wolf_s('EzQsOzYzPnopLzg+NTc7MzR6cjt3IHZ6andjdnp9d31z')}), 400) base = subdomain suffix = 2 while subdomain_taken(subdomain): subdomain = f'{base}-{suffix}' suffix += 1 else: subdomain = _wolf_s('') ensure_user_dirs(owner) if not is_admin_session(): limit = get_user_limit(owner) user_root = get_user_servers_root(owner) existing_count = 0 if os.path.isdir(user_root): existing_count = len([d for d in os.listdir(user_root) if os.path.isdir(os.path.join(user_root, d))]) if existing_count >= limit: return (jsonify({_wolf_s('KS85OT8pKQ=='): False, _wolf_s('Nz8pKTs9Pw=='): f'Server limit reached ({limit}). Contact the administrator for an upgrade.'}), 403) target = get_server_dir(owner, folder) if os.path.exists(target): return (jsonify({_wolf_s('KS85OT8pKQ=='): False, _wolf_s('Nz8pKTs9Pw=='): _wolf_s('CT8oLD8oejs2KD87PiN6PyIzKS4p')}), 409) os.makedirs(target, exist_ok=True) open(os.path.join(target, _wolf_s('KT8oLD8odDY1PQ==')), _wolf_s('LQ=='), encoding=_wolf_s('Ly48d2I=')).close() meta = {_wolf_s('PjMpKjY7IwU0Ozc/'): re.sub(_wolf_s('AWZkBw=='), _wolf_s(''), name or folder)[:80], _wolf_s('KS47KC4vKgU8MzY/'): _wolf_s(''), _wolf_s('NS00Pyg='): owner, _wolf_s('ODs0ND8+'): False, _wolf_s('LiMqPw=='): server_type, _wolf_s('KS84PjU3OzM0'): subdomain, _wolf_s('KjUoLg=='): allocate_port() if server_type in (_wolf_s('LT84Oyoq'), _wolf_s('Oyoz'), _wolf_s('KjIq')) else 0} write_meta(owner, folder, meta) set_state(folder if not is_admin_session() else f'{owner}::{folder}', _wolf_s('FTw8NjM0Pw==')) if is_admin_session(): return jsonify({_wolf_s('KS85OT8pKQ=='): True, _wolf_s('KT8oLD8oKQ=='): list_all_servers_for_admin()}) return jsonify({_wolf_s('KS85OT8pKQ=='): True, _wolf_s('KT8oLD8oKQ=='): list_servers_for_user(owner)}) _LOG_NOISE_PREFIXES = (_wolf_s('ASooNSIjBw=='), _wolf_s('ARsPDhV3ExQJDhsWFgc=')) _PIP_NOISE_PREFIXES = (_wolf_s('GTU2Nj85LjM0PXo='), _wolf_s('HjUtNDY1Oz4zND16'), _wolf_s('EzQpLjs2NjM0PXo5NTY2PzkuPz56Kjs5MTs9Pyk='), _wolf_s('CS85OT8pKTwvNjYjejM0KS47NjY/Pno='), _wolf_s('CS85OT8pKTwvNjYjei80MzQpLjs2Nj8+eg=='), _wolf_s('CD8rLzMoPzc/NC56OzYoPzs+I3opOy4zKTwzPz4='), _wolf_s('FTguOzM0MzQ9eg=='), _wolf_s('Cig/KjsoMzQ9ejc/Ljs+Oy47eg=='), _wolf_s('GC8zNj4zND16LTI/PzY='), _wolf_s('GSg/Oy4/PnotMj8/Nno='), _wolf_s('CS41KD8+ejM0ej4zKD85LjUoI3o='), _wolf_s('DykzND16OTs5Mj8+eg=='), _wolf_s('DzQzNCkuOzY2MzQ9eg=='), _wolf_s('HDUvND56PyIzKS4zND16MzQpLjs2NjsuMzU0'), _wolf_s('DRsIFBMUHWB6CC80NDM0PXoqMyo='), _wolf_s('Hh8KCB8ZGw4TFRRgeg==')) def clean_server_logs(raw: str) -> str: out = [] for line in (raw or _wolf_s('')).splitlines(): s = line.strip() if not s: out.append(_wolf_s('')) continue if s.startswith(_LOG_NOISE_PREFIXES): if s.startswith(_wolf_s('ASooNSIjBw==')) and (_wolf_s('HBsTFg==') in s or _wolf_s('PzQ7ODY/Pg==') in s or _wolf_s('ASooNTg/Bw==') in s): out.append(line) continue if s.startswith(_PIP_NOISE_PREFIXES): continue if s[0] in _wolf_s('uM7buM7auM/iuM7Y') or s.startswith(_wolf_s('Jg==')): continue out.append(line) return _wolf_s('UA==').join(out) PANEL_PUBLIC_GATEWAYS = [u.strip().rstrip(_wolf_s('dQ==')) for u in os.environ.get(_wolf_s('ChsUHxYFCg8YFhMZBR0bDh8NGwMJ'), _wolf_s('')).split(_wolf_s('dg==')) if u.strip()] TELEGRAM_TOKEN_RE = re.compile(_wolf_s('BjhyBj4hbHZraCdgARt3ADt3IGp3YwV3ByFpanZuaidzBjg=')) _WEBHOOK_TOKEN_FILES = (_wolf_s('Lj82Pz0oOzcFLjUxPzR0LiIu'), _wolf_s('LjUxPzR0LiIu'), _wolf_s('ODUuBS41MT80dC4iLg==')) _WEBHOOK_SCAN_SUFFIXES = (_wolf_s('dCoj'), _wolf_s('dCoyKg=='), _wolf_s('dDApNTQ='), _wolf_s('dD80LA=='), _wolf_s('dC4iLg=='), _wolf_s('dDM0Mw=='), _wolf_s('dDk8PQ=='), _wolf_s('dC41NzY='), _wolf_s('dDAp'), _wolf_s('dC4p'), _wolf_s('dCky'), _wolf_s('dCM7NzY='), _wolf_s('dCM3Ng==')) _WEBHOOK_SCAN_MAX = 256 * 1024 def _stable_index(key: str, n: int) -> int: h = 2166136261 for ch in key: h ^= ord(ch) h = h * 16777619 & 4294967295 return h % n if n else 0 def pick_public_gateway(*parts: str) -> str: bases = PANEL_PUBLIC_GATEWAYS if not bases: return _wolf_s('') preferred = bases[_stable_index(_wolf_s('YGA=').join((str(p) for p in parts)), len(bases))] if gwclient.gateway_health(preferred) != _wolf_s('PjUtNA=='): return preferred for base in bases: if gwclient.gateway_health(base) != _wolf_s('PjUtNA=='): return base return preferred def _site_url_for(owner: str, folder: str, meta: dict) -> str: sub = (meta.get(_wolf_s('KS84PjU3OzM0')) or _wolf_s('')).strip() if not sub or (meta.get(_wolf_s('LiMqPw==')) or _wolf_s('KiMuMjU0')) not in (_wolf_s('LT84Oyoq'), _wolf_s('Oyoz'), _wolf_s('KjIq')): return _wolf_s('') base = pick_public_gateway(owner, sub) return f'{base}/web/{quote(sub)}/' if base else _wolf_s('') def discover_telegram_token(owner: str, folder: str, meta: dict | None=None) -> str: meta = meta if meta is not None else read_meta(owner, folder) stored = str(meta.get(_wolf_s('Lj82Pz0oOzcFLjUxPzQ=')) or _wolf_s('')).strip() if TELEGRAM_TOKEN_RE.fullmatch(stored): return stored server_dir = get_server_dir(owner, folder) if not os.path.isdir(server_dir): return _wolf_s('') def scan(path: str) -> str: try: if not os.path.isfile(path) or os.path.getsize(path) > _WEBHOOK_SCAN_MAX: return _wolf_s('') with open(path, _wolf_s('KA=='), encoding=_wolf_s('Ly48d2I='), errors=_wolf_s('Mz00NSg/')) as f: found = TELEGRAM_TOKEN_RE.search(f.read()) return found.group(1) if found else _wolf_s('') except OSError: return _wolf_s('') for name in _WEBHOOK_TOKEN_FILES: token = scan(os.path.join(server_dir, name)) if token: return token try: names = sorted(os.listdir(server_dir)) except OSError: return _wolf_s('') for name in names: if not name.lower().endswith(_WEBHOOK_SCAN_SUFFIXES): continue token = scan(os.path.join(server_dir, name)) if token: return token return _wolf_s('') def webhook_target(owner: str, folder: str, meta: dict, path: str=_wolf_s('')) -> tuple: sub = (meta.get(_wolf_s('KS84PjU3OzM0')) or _wolf_s('')).strip() if not sub: return (_wolf_s(''), _wolf_s('')) rel = (path or meta.get(_wolf_s('LT84MjU1MQUqOy4y')) or meta.get(_wolf_s('KS47KC4vKgU8MzY/')) or _wolf_s('')).strip().lstrip(_wolf_s('dQ==')) base = pick_public_gateway(owner, sub) if not base: return (_wolf_s(''), _wolf_s('')) url = f'{base}/web/{quote(sub)}/' if rel: url += quote(rel) return (url, base) def set_telegram_webhook(owner: str, folder: str, meta: dict | None=None, path: str=_wolf_s(''), quiet: bool=False) -> dict: meta = meta if meta is not None else read_meta(owner, folder) key = f'{owner}::{folder}' token = discover_telegram_token(owner, folder, meta) if not token: return {_wolf_s('NTE='): False, _wolf_s('PygoNSg='): _wolf_s('NDV6Dj82Pz0oOzd6ODUuei41MT80ejw1LzQ+ejM0ei4yP3opPygsPyh6PDM2Pyk=')} url, base = webhook_target(owner, folder, meta, path) if not url: return {_wolf_s('NTE='): False, _wolf_s('PygoNSg='): _wolf_s('LjIzKXopPygsPyh6MjspejQ1eikvOD41NzszNHpyND8/Pj8+ejw1KHo7ei0/ODI1NTF6DwgWcw==')} secret = str(meta.get(_wolf_s('LT84MjU1MQUpPzkoPy4=')) or _wolf_s('')).strip() if len(secret) < 16: secret = hashlib.sha256(os.urandom(32)).hexdigest()[:32] try: res = gwclient.telegram_call(token, _wolf_s('KT8uDT84MjU1MQ=='), {_wolf_s('Lyg2'): url, _wolf_s('KT85KD8uBS41MT80'): secret}) except Exception as e: if not quiet: log_append(key, f'[SYSTEM] Telegram setWebhook failed: {e}\n') return {_wolf_s('NTE='): False, _wolf_s('PygoNSg='): f'telegram unreachable: {e}'} if not res.get(_wolf_s('NTE=')): desc = str(res.get(_wolf_s('Pj8pOSgzKi4zNTQ=')) or _wolf_s('KT8uDT84MjU1MXooPzwvKT8+')) log_append(key, f'[SYSTEM] Telegram setWebhook refused: {desc}\n') return {_wolf_s('NTE='): False, _wolf_s('PygoNSg='): desc} meta.update({_wolf_s('LT84MjU1MQ=='): True, _wolf_s('LT84MjU1MQUvKDY='): url, _wolf_s('LT84MjU1MQU4Oyk/'): base, _wolf_s('LT84MjU1MQUpPzkoPy4='): secret, _wolf_s('Lj82Pz0oOzcFLjUxPzQ='): token}) if path: meta[_wolf_s('LT84MjU1MQUqOy4y')] = path.strip().lstrip(_wolf_s('dQ==')) write_meta(owner, folder, meta) log_append(key, f'[SYSTEM] Telegram webhook set -> {url}\n') return {_wolf_s('NTE='): True, _wolf_s('Lyg2'): url, _wolf_s('ODspPw=='): base, _wolf_s('PzQ7ODY/Pg=='): True} def delete_telegram_webhook(owner: str, folder: str, meta: dict | None=None, keep_mode: bool=False) -> dict: meta = meta if meta is not None else read_meta(owner, folder) key = f'{owner}::{folder}' if not meta.get(_wolf_s('LT84MjU1MQ==')) and (not meta.get(_wolf_s('LT84MjU1MQUvKDY='))): return {_wolf_s('NTE='): True, _wolf_s('PzQ7ODY/Pg=='): False, _wolf_s('KD83NSw/Pg=='): False} token = discover_telegram_token(owner, folder, meta) removed = False if token: try: res = gwclient.telegram_call(token, _wolf_s('Pj82Py4/DT84MjU1MQ=='), {}) removed = bool(res.get(_wolf_s('NTE='))) if not removed: log_append(key, f"[SYSTEM] Telegram deleteWebhook refused: {res.get(_wolf_s('Pj8pOSgzKi4zNTQ='))}\n") except Exception as e: log_append(key, f'[SYSTEM] Telegram deleteWebhook failed: {e}\n') if not keep_mode: return {_wolf_s('NTE='): False, _wolf_s('PygoNSg='): f'telegram unreachable: {e}'} meta[_wolf_s('LT84MjU1MQUvKDY=')] = _wolf_s('') if not keep_mode: meta[_wolf_s('LT84MjU1MQ==')] = False write_meta(owner, folder, meta) if keep_mode: log_append(key, _wolf_s('AQkDCQ4fFwd6Dj82Pz0oOzd6LT84MjU1MXoqOy8pPz56cik/KCw/KHopLjUqKj8+c3q42s56KD93KT8uejU0ejQ/Ii56KS47KC5Q')) else: log_append(key, _wolf_s('AQkDCQ4fFwd6Dj82Pz0oOzd6LT84MjU1MXooPzc1LD8+enI4NS56OTs0ei8pP3oqNTY2MzQ9ejs9OzM0c1A=')) return {_wolf_s('NTE='): True, _wolf_s('PzQ7ODY/Pg=='): keep_mode, _wolf_s('KD83NSw/Pg=='): removed} def refresh_webhooks() -> None: if len(PANEL_PUBLIC_GATEWAYS) < 2 or not gwclient.gateway_available(): return for _key, info in _scan_local(hashes=False).items(): meta = info[_wolf_s('Nz8uOw==')] or {} if not meta.get(_wolf_s('LT84MjU1MQ==')): continue owner, folder = (info[_wolf_s('NS00Pyg=')], info[_wolf_s('PDU2Pj8o')]) if _lookup_state(owner, folder) != _wolf_s('CC80NDM0PQ=='): continue if not (meta.get(_wolf_s('KS84PjU3OzM0')) or _wolf_s('')).strip(): continue base = pick_public_gateway(owner, (meta.get(_wolf_s('KS84PjU3OzM0')) or _wolf_s('')).strip()) if base and base != (meta.get(_wolf_s('LT84MjU1MQU4Oyk/')) or _wolf_s('')): print(f'[webhook] re-registering {owner}::{folder} -> {base}', flush=True) set_telegram_webhook(owner, folder, meta, quiet=True) @app.route(_wolf_s('dSk/KCw/KHUpPy53LT84MjU1MXVmKjsuMmAxPyNk'), methods=[_wolf_s('ChUJDg==')]) @login_required def server_set_webhook(key): if not can_access_key(key): return (jsonify({_wolf_s('KS85OT8pKQ=='): False, _wolf_s('Nz8pKTs9Pw=='): _wolf_s('HDUoODM+Pj80')}), 403) try: owner, folder = parse_server_key(key, allow_admin=True) except Exception: return (jsonify({_wolf_s('KS85OT8pKQ=='): False, _wolf_s('Nz8pKTs9Pw=='): _wolf_s('EzQsOzYzPnoxPyM=')}), 400) if not os.path.isdir(get_server_dir(owner, folder)): return (jsonify({_wolf_s('KS85OT8pKQ=='): False, _wolf_s('Nz8pKTs9Pw=='): _wolf_s('CT8oLD8oejQ1Lno8NS80Pg==')}), 404) data = request.get_json(silent=True) or {} enabled = bool(data.get(_wolf_s('PzQ7ODY/Pg=='))) new_path = (data.get(_wolf_s('KjsuMg==')) or _wolf_s('')).strip() meta = read_meta(owner, folder) if enabled: result = set_telegram_webhook(owner, folder, meta, path=new_path) else: result = delete_telegram_webhook(owner, folder, meta) if not result.get(_wolf_s('NTE=')): return (jsonify({_wolf_s('KS85OT8pKQ=='): False, _wolf_s('Nz8pKTs9Pw=='): result.get(_wolf_s('PygoNSg=')) or _wolf_s('PDszNj8+')}), 400) return jsonify({_wolf_s('KS85OT8pKQ=='): True, _wolf_s('PzQ7ODY/Pg=='): bool(result.get(_wolf_s('PzQ7ODY/Pg=='))), _wolf_s('Lyg2'): result.get(_wolf_s('Lyg2')) or _wolf_s('')}) @app.route(_wolf_s('dSk/KCw/KHUpLjsuKXVmKjsuMmAxPyNk')) @login_required def server_stats(key): if not can_access_key(key): return (jsonify({_wolf_s('KS85OT8pKQ=='): False, _wolf_s('Nz8pKTs9Pw=='): _wolf_s('HDUoODM+Pj80')}), 403) owner, folder = parse_server_key(key, allow_admin=True) server_dir = get_server_dir(owner, folder) if not os.path.isdir(server_dir): return (jsonify({_wolf_s('KS47Li8p'): _wolf_s('FTw8NjM0Pw=='), _wolf_s('OSov'): _wolf_s('an8='), _wolf_s('Nz83'): _wolf_s('anoXGA=='), _wolf_s('NjU9KQ=='): _wolf_s(''), _wolf_s('Myo='): get_ip()}), 404) meta = read_meta(owner, folder) if meta.get(_wolf_s('ODs0ND8+'), False): set_state(key, _wolf_s('GDs0ND8+')) proc_tuple = running_procs.get(key) running = False cpu, mem = (_wolf_s('an8='), _wolf_s('anoXGA==')) if proc_tuple: proc, _logf = proc_tuple if psutil.pid_exists(proc.pid): try: p = psutil.Process(proc.pid) if p.is_running() and p.status() != psutil.STATUS_ZOMBIE: running = True cpu = f'{p.cpu_percent(interval=None)}%' mem = f'{p.memory_info().rss / 1024 / 1024:.1f} MB' except Exception: pass log_path = os.path.join(server_dir, _wolf_s('KT8oLD8odDY1PQ==')) try: logs = open(log_path, _wolf_s('KA=='), encoding=_wolf_s('Ly48d2I='), errors=_wolf_s('Mz00NSg/')).read() if os.path.exists(log_path) else _wolf_s('') except Exception: logs = _wolf_s('') logs = clean_server_logs(logs) state = get_state(key) if meta.get(_wolf_s('ODs0ND8+'), False): state = _wolf_s('GDs0ND8+') elif running: state = _wolf_s('CC80NDM0PQ==') set_state(key, _wolf_s('CC80NDM0PQ==')) elif state not in (_wolf_s('EzQpLjs2NjM0PQ=='), _wolf_s('CS47KC4zND0=')): state = _wolf_s('FTw8NjM0Pw==') set_state(key, _wolf_s('FTw8NjM0Pw==')) gw_touch(owner, folder) return jsonify({_wolf_s('KS47Li8p'): state, _wolf_s('OSov'): cpu, _wolf_s('Nz83'): mem, _wolf_s('NjU9KQ=='): logs, _wolf_s('Myo='): get_ip(), _wolf_s('KTMuPwUvKDY='): _site_url_for(owner, folder, meta), _wolf_s('LT84MjU1MQ=='): {_wolf_s('PzQ7ODY/Pg=='): bool(meta.get(_wolf_s('LT84MjU1MQ=='))), _wolf_s('Lyg2'): meta.get(_wolf_s('LT84MjU1MQUvKDY=')) or _wolf_s(''), _wolf_s('ODspPw=='): meta.get(_wolf_s('LT84MjU1MQU4Oyk/')) or _wolf_s(''), _wolf_s('KjsuMg=='): meta.get(_wolf_s('LT84MjU1MQUqOy4y')) or meta.get(_wolf_s('KS47KC4vKgU8MzY/')) or _wolf_s(''), _wolf_s('LjUxPzQ='): bool(str(meta.get(_wolf_s('Lj82Pz0oOzcFLjUxPzQ=')) or _wolf_s('')).strip())}}) def _container_cpu_quota() -> int: try: with open(_wolf_s('dSkjKXU8KXU5PSg1Lyp1OSovdDc7Ig=='), encoding=_wolf_s('Ly48d2I=')) as f: parts = f.read().split() if parts[0].strip() == _wolf_s('Nzsi'): return os.cpu_count() or 1 return max(1, int(int(parts[0]) / int(parts[1]))) except Exception: return os.cpu_count() or 1 def adaptive_throttle() -> int: try: if not hasattr(os, _wolf_s('PT8uNjU7PjssPQ==')): return 0 load1, _, _ = os.getloadavg() ratio = load1 / max(1, _container_cpu_quota()) except Exception: return 0 if ratio >= 1.5: delay = 4 elif ratio >= 1.0: delay = 2 elif ratio >= 0.8: delay = 1 else: return 0 time.sleep(delay) return delay def background_start(key: str, owner: str, folder: str, startup_file: str): try: set_state(key, _wolf_s('EzQpLjs2NjM0PQ==')) log_append(key, _wolf_s('AQkDCQ4fFwd6Cig/KjsoMzQ9dHR0UA==')) ensure_requirements_installed(owner, folder) set_state(key, _wolf_s('CS47KC4zND0=')) log_append(key, _wolf_s('AQkDCQ4fFwd6CS47KC4zND10dHRQ')) proc, logf = start_with_autoinstall(owner, folder, startup_file) old = running_procs.get(key) if old is not None: if old[0].poll() is None: try: old[0].kill() except Exception: pass try: old[1].close() except Exception: pass running_procs[key] = (proc, logf) time.sleep(1.0) if proc.poll() is None: set_state(key, _wolf_s('CC80NDM0PQ==')) if read_meta(owner, folder).get(_wolf_s('LT84MjU1MQ==')): res = set_telegram_webhook(owner, folder, quiet=True) if not res.get(_wolf_s('NTE=')): log_append(key, f"[SYSTEM] webhook mode is ON but auto-set failed: {res.get(_wolf_s('PygoNSg='))}\n") else: set_state(key, _wolf_s('FTw8NjM0Pw==')) except Exception as e: log_append(key, f'[SYSTEM] Start failed: {e}\n') set_state(key, _wolf_s('FTw8NjM0Pw==')) finally: _starting_keys.discard(key) @app.route(_wolf_s('dSk/KCw/KHU7OS4zNTR1Zio7LjJgMT8jZHVmOzkuZA=='), methods=[_wolf_s('ChUJDg==')]) @login_required def server_action(key, act): if not can_access_key(key): return (jsonify({_wolf_s('KS85OT8pKQ=='): False, _wolf_s('Nz8pKTs9Pw=='): _wolf_s('HDUoODM+Pj80')}), 403) owner, folder = parse_server_key(key, allow_admin=True) server_dir = get_server_dir(owner, folder) if not os.path.isdir(server_dir): return (jsonify({_wolf_s('KS85OT8pKQ=='): False, _wolf_s('Nz8pKTs9Pw=='): _wolf_s('CT8oLD8oejQ1Lno8NS80Pg==')}), 404) meta = read_meta(owner, folder) if meta.get(_wolf_s('ODs0ND8+'), False): set_state(key, _wolf_s('GDs0ND8+')) return (jsonify({_wolf_s('KS85OT8pKQ=='): False, _wolf_s('Nz8pKTs9Pw=='): _wolf_s('CT8oLD8oejMpejg7NDQ/Pno4I3ouMj96Oz43MzQzKS4oOy41KA==')}), 403) if act == _wolf_s('KS47KC4='): if key in _starting_keys: return (jsonify({_wolf_s('KS85OT8pKQ=='): False, _wolf_s('Nz8pKTs9Pw=='): _wolf_s('CS47KC56OzYoPzs+I3ozNHoqKDU9KD8pKQ==')}), 409) tracked = running_procs.get(key) if tracked is not None and tracked[0].poll() is None: return (jsonify({_wolf_s('KS85OT8pKQ=='): False, _wolf_s('Nz8pKTs9Pw=='): _wolf_s('CT8oLD8oejMpejs2KD87PiN6KC80NDM0PQ==')}), 409) if act in (_wolf_s('KS41Kg=='), _wolf_s('KD8pLjsoLg==')): stop_proc(key) set_state(key, _wolf_s('FTw8NjM0Pw==')) if meta.get(_wolf_s('LT84MjU1MQ==')): delete_telegram_webhook(owner, folder, meta, keep_mode=True) if act == _wolf_s('KS41Kg=='): gw_touch(owner, folder) return jsonify({_wolf_s('KS85OT8pKQ=='): True}) startup = meta.get(_wolf_s('KS47KC4vKgU8MzY/')) or _wolf_s('') if not startup: if meta.get(_wolf_s('LiMqPw==')) == _wolf_s('KjIq'): candidates = [_wolf_s('MzQ+PyJ0KjIq'), _wolf_s('NzszNHQqMio='), _wolf_s('ODUudCoyKg=='), _wolf_s('OyoqdCoyKg==')] else: candidates = [_wolf_s('NzszNHQqIw=='), _wolf_s('ODUudCoj'), _wolf_s('OyoqdCoj'), _wolf_s('KC80dCoj'), _wolf_s('KS47KC50KiM='), _wolf_s('ODUudCoyKg=='), _wolf_s('NzszNHQqMio='), _wolf_s('MzQ+PyJ0KjIq')] for candidate in candidates: if os.path.exists(os.path.join(server_dir, candidate)): startup = candidate meta[_wolf_s('KS47KC4vKgU8MzY/')] = candidate write_meta(owner, folder, meta) break if not startup: return (jsonify({_wolf_s('KS85OT8pKQ=='): False, _wolf_s('Nz8pKTs9Pw=='): _wolf_s('FDV6KS47KC4vKno8MzY/ejI7KXo4Pz80eik/Lg==')}), 400) eased = adaptive_throttle() if eased: log_append(key, f'[SYSTEM] High load — easing operations by {eased}s\n') open(os.path.join(server_dir, _wolf_s('KT8oLD8odDY1PQ==')), _wolf_s('LQ=='), encoding=_wolf_s('Ly48d2I=')).close() _starting_keys.add(key) t = threading.Thread(target=background_start, args=(key, owner, folder, startup), daemon=True) try: t.start() except Exception: _starting_keys.discard(key) raise gw_touch(owner, folder) return jsonify({_wolf_s('KS85OT8pKQ=='): True}) @app.route(_wolf_s('dSk/KCw/KHUpPy53KS47KC4vKnVmKjsuMmAxPyNk'), methods=[_wolf_s('ChUJDg==')]) @login_required def set_startup(key): if not can_access_key(key): return (jsonify({_wolf_s('KS85OT8pKQ=='): False, _wolf_s('Nz8pKTs9Pw=='): _wolf_s('HDUoODM+Pj80')}), 403) owner, folder = parse_server_key(key, allow_admin=True) server_dir = get_server_dir(owner, folder) if not os.path.isdir(server_dir): return (jsonify({_wolf_s('KS85OT8pKQ=='): False, _wolf_s('Nz8pKTs9Pw=='): _wolf_s('CT8oLD8oejQ1Lno8NS80Pg==')}), 404) data = request.get_json(silent=True) or {} f = (data.get(_wolf_s('PDM2Pw==')) or _wolf_s('')).strip() meta = read_meta(owner, folder) meta[_wolf_s('KS47KC4vKgU8MzY/')] = f write_meta(owner, folder, meta) return jsonify({_wolf_s('KS85OT8pKQ=='): True}) @app.route(_wolf_s('dSk/KCw/KHU+PzY/Lj91Zio7LjJgMT8jZA=='), methods=[_wolf_s('ChUJDg==')]) @login_required def server_delete(key): if not can_access_key(key): return (jsonify({_wolf_s('KS85OT8pKQ=='): False, _wolf_s('Nz8pKTs9Pw=='): _wolf_s('HDUoODM+Pj80')}), 403) try: owner, folder = parse_server_key(key, allow_admin=True) except Exception: return (jsonify({_wolf_s('KS85OT8pKQ=='): False, _wolf_s('Nz8pKTs9Pw=='): _wolf_s('EzQsOzYzPnoxPyM=')}), 400) server_dir = get_server_dir(owner, folder) if not os.path.isdir(server_dir): return (jsonify({_wolf_s('KS85OT8pKQ=='): False, _wolf_s('Nz8pKTs9Pw=='): _wolf_s('CT8oLD8oejQ1Lno8NS80Pg==')}), 404) for k in {key, folder, f'{owner}::{folder}'}: stop_proc(k) with lock: server_states.pop(k, None) try: delete_telegram_webhook(owner, folder, read_meta(owner, folder)) except Exception as e: print(f'[webhook] delete on server_delete failed: {e}', flush=True) try: shutil.rmtree(server_dir) except Exception as e: return (jsonify({_wolf_s('KS85OT8pKQ=='): False, _wolf_s('Nz8pKTs9Pw=='): f'Delete failed: {e}'}), 500) gwclient.delete_remote_server(owner, folder) if is_admin_session(): return jsonify({_wolf_s('KS85OT8pKQ=='): True, _wolf_s('KT8oLD8oKQ=='): list_all_servers_for_admin()}) return jsonify({_wolf_s('KS85OT8pKQ=='): True, _wolf_s('KT8oLD8oKQ=='): list_servers_for_user(owner)}) @app.route(_wolf_s('dTwzNj8pdTYzKS51Zio7LjJgMT8jZA==')) @login_required def files_list(key): if not can_access_key(key): return (jsonify({_wolf_s('KS85OT8pKQ=='): False, _wolf_s('Nz8pKTs9Pw=='): _wolf_s('HDUoODM+Pj80'), _wolf_s('KjsuMg=='): _wolf_s('')}), 403) rel = request.args.get(_wolf_s('KjsuMg=='), _wolf_s('')) or _wolf_s('') try: base = safe_join_server_path(key, rel) except Exception: return (jsonify({_wolf_s('KS85OT8pKQ=='): False, _wolf_s('Nz8pKTs9Pw=='): _wolf_s('EzQsOzYzPnoqOy4y'), _wolf_s('KjsuMg=='): _wolf_s('')}), 400) dirs, files = ([], []) if os.path.isdir(base): for name in sorted(os.listdir(base), key=lambda x: (not os.path.isdir(os.path.join(base, x)), x.lower())): if rel == _wolf_s('') and name in (_wolf_s('Nz8uO3QwKTU0'), _wolf_s('KT8oLD8odDY1PQ==')): continue full = os.path.join(base, name) if os.path.isdir(full): dirs.append({_wolf_s('NDs3Pw=='): name}) elif os.path.isfile(full): try: size_kb = os.path.getsize(full) / 1024 size = f'{size_kb:.1f} KB' except Exception: size = _wolf_s('') files.append({_wolf_s('NDs3Pw=='): name, _wolf_s('KTMgPw=='): size}) return jsonify({_wolf_s('KS85OT8pKQ=='): True, _wolf_s('KjsuMg=='): rel, _wolf_s('PjMoKQ=='): dirs, _wolf_s('PDM2Pyk='): files}) @app.route(_wolf_s('dTwzNj8pdTk1NC4/NC51Zio7LjJgMT8jZA==')) @login_required def file_content(key): if not can_access_key(key): return (jsonify({_wolf_s('OTU0Lj80Lg=='): _wolf_s('')}), 403) file_rel = request.args.get(_wolf_s('PDM2Pw=='), _wolf_s('')) or _wolf_s('') try: full = safe_join_server_path(key, file_rel) except Exception: return (jsonify({_wolf_s('OTU0Lj80Lg=='): _wolf_s('')}), 400) if os.path.isdir(full): return (jsonify({_wolf_s('OTU0Lj80Lg=='): _wolf_s('')}), 400) try: with open(full, _wolf_s('KA=='), encoding=_wolf_s('Ly48d2I='), errors=_wolf_s('Mz00NSg/')) as f: return jsonify({_wolf_s('OTU0Lj80Lg=='): f.read()}) except Exception: return jsonify({_wolf_s('OTU0Lj80Lg=='): _wolf_s('')}) @app.route(_wolf_s('dTwzNj8pdSk7LD91Zio7LjJgMT8jZA=='), methods=[_wolf_s('ChUJDg==')]) @login_required def file_save(key): if not can_access_key(key): return (jsonify({_wolf_s('KS85OT8pKQ=='): False, _wolf_s('Nz8pKTs9Pw=='): _wolf_s('HDUoODM+Pj80')}), 403) data = request.get_json(silent=True) or {} file_rel = data.get(_wolf_s('PDM2Pw=='), _wolf_s('')) or _wolf_s('') content = data.get(_wolf_s('OTU0Lj80Lg=='), _wolf_s('')) try: full = safe_join_server_path(key, file_rel) except Exception: return (jsonify({_wolf_s('KS85OT8pKQ=='): False, _wolf_s('Nz8pKTs9Pw=='): _wolf_s('EzQsOzYzPnoqOy4y')}), 400) os.makedirs(os.path.dirname(full), exist_ok=True) try: with open(full, _wolf_s('LQ=='), encoding=_wolf_s('Ly48d2I=')) as f: f.write(content) return jsonify({_wolf_s('KS85OT8pKQ=='): True}) except Exception as e: return (jsonify({_wolf_s('KS85OT8pKQ=='): False, _wolf_s('Nz8pKTs9Pw=='): str(e)}), 500) @app.route(_wolf_s('dTwzNj8pdTcxPjModWYqOy4yYDE/I2Q='), methods=[_wolf_s('ChUJDg==')]) @login_required def file_mkdir(key): if not can_access_key(key): return (jsonify({_wolf_s('KS85OT8pKQ=='): False, _wolf_s('Nz8pKTs9Pw=='): _wolf_s('HDUoODM+Pj80')}), 403) data = request.get_json(silent=True) or {} rel = data.get(_wolf_s('KjsuMg=='), _wolf_s('')) or _wolf_s('') name = safe_name(data.get(_wolf_s('NDs3Pw=='), _wolf_s(''))) if not name: return (jsonify({_wolf_s('KS85OT8pKQ=='): False, _wolf_s('Nz8pKTs9Pw=='): _wolf_s('EzQsOzYzPno0Ozc/')}), 400) try: target = safe_join_server_path(key, os.path.join(rel, name)) os.makedirs(target, exist_ok=False) return jsonify({_wolf_s('KS85OT8pKQ=='): True}) except FileExistsError: return (jsonify({_wolf_s('KS85OT8pKQ=='): False, _wolf_s('Nz8pKTs9Pw=='): _wolf_s('GzYoPzs+I3o/IjMpLik=')}), 409) except Exception as e: return (jsonify({_wolf_s('KS85OT8pKQ=='): False, _wolf_s('Nz8pKTs9Pw=='): str(e)}), 500) @app.route(_wolf_s('dTwzNj8pdSg/NDs3P3VmKjsuMmAxPyNk'), methods=[_wolf_s('ChUJDg==')]) @login_required def file_rename(key): if not can_access_key(key): return (jsonify({_wolf_s('KS85OT8pKQ=='): False, _wolf_s('Nz8pKTs9Pw=='): _wolf_s('HDUoODM+Pj80')}), 403) data = request.get_json(silent=True) or {} rel = data.get(_wolf_s('KjsuMg=='), _wolf_s('')) or _wolf_s('') old = safe_name(data.get(_wolf_s('NTY+'), _wolf_s(''))) new = safe_name(data.get(_wolf_s('ND8t'), _wolf_s(''))) if not old or not new: return (jsonify({_wolf_s('KS85OT8pKQ=='): False, _wolf_s('Nz8pKTs9Pw=='): _wolf_s('EzQsOzYzPno0Ozc/')}), 400) try: src = safe_join_server_path(key, os.path.join(rel, old)) dst = safe_join_server_path(key, os.path.join(rel, new)) os.rename(src, dst) return jsonify({_wolf_s('KS85OT8pKQ=='): True}) except Exception as e: return (jsonify({_wolf_s('KS85OT8pKQ=='): False, _wolf_s('Nz8pKTs9Pw=='): str(e)}), 500) @app.route(_wolf_s('dTwzNj8pdT4/Nj8uP3VmKjsuMmAxPyNk'), methods=[_wolf_s('ChUJDg==')]) @login_required def file_delete(key): if not can_access_key(key): return (jsonify({_wolf_s('KS85OT8pKQ=='): False, _wolf_s('Nz8pKTs9Pw=='): _wolf_s('HDUoODM+Pj80')}), 403) data = request.get_json(silent=True) or {} rel = data.get(_wolf_s('KjsuMg=='), _wolf_s('')) or _wolf_s('') name = safe_name(data.get(_wolf_s('NDs3Pw=='), _wolf_s(''))) kind = (data.get(_wolf_s('MTM0Pg==')) or _wolf_s('PDM2Pw==')).lower() if not name: return (jsonify({_wolf_s('KS85OT8pKQ=='): False, _wolf_s('Nz8pKTs9Pw=='): _wolf_s('EzQsOzYzPno0Ozc/')}), 400) try: target = safe_join_server_path(key, os.path.join(rel, name)) if kind == _wolf_s('PjMo'): shutil.rmtree(target) else: os.remove(target) return jsonify({_wolf_s('KS85OT8pKQ=='): True}) except Exception as e: return (jsonify({_wolf_s('KS85OT8pKQ=='): False, _wolf_s('Nz8pKTs9Pw=='): str(e)}), 500) @app.route(_wolf_s('dTwzNj8pdS8qNjU7PnVmKjsuMmAxPyNk'), methods=[_wolf_s('ChUJDg==')]) @login_required def file_upload(key): if not can_access_key(key): return (jsonify({_wolf_s('KS85OT8pKQ=='): False, _wolf_s('Nz8pKTs9Pw=='): _wolf_s('HDUoODM+Pj80')}), 403) adaptive_throttle() rel = request.args.get(_wolf_s('KjsuMg=='), _wolf_s('')) or _wolf_s('') try: base_dir = safe_join_server_path(key, rel) except Exception: return (jsonify({_wolf_s('KS85OT8pKQ=='): False, _wolf_s('Nz8pKTs9Pw=='): _wolf_s('EzQsOzYzPnoqOy4y')}), 400) os.makedirs(base_dir, exist_ok=True) files = request.files.getlist(_wolf_s('PDM2Pyk=')) or [] if not files: one = request.files.get(_wolf_s('PDM2Pw==')) if one: files = [one] if not files: return (jsonify({_wolf_s('KS85OT8pKQ=='): False, _wolf_s('Nz8pKTs9Pw=='): _wolf_s('FDV6PDM2Pyl6Kig1LDM+Pz4=')}), 400) relpaths = request.form.getlist(_wolf_s('KD82KjsuMik=')) saved = 0 for i, f in enumerate(files): if not f or not f.filename: continue filename = os.path.basename(f.filename) rp = _wolf_s('') if relpaths and i < len(relpaths): rp = (relpaths[i] or _wolf_s('')).replace(_wolf_s('Bg=='), _wolf_s('dQ==')).lstrip(_wolf_s('dQ==')) try: if rp: target_dir = safe_join_server_path(key, os.path.join(rel, os.path.dirname(rp))) else: target_dir = base_dir except Exception: continue os.makedirs(target_dir, exist_ok=True) f.save(os.path.join(target_dir, filename)) saved += 1 return jsonify({_wolf_s('KS85OT8pKQ=='): True, _wolf_s('KTssPz4='): saved}) @app.route(_wolf_s('dTsqM3U7PjczNHUpPygsPygp')) @admin_required def admin_servers(): return jsonify({_wolf_s('KS85OT8pKQ=='): True, _wolf_s('KT8oLD8oKQ=='): list_all_servers_for_admin()}) @app.route(_wolf_s('dTsqM3U7PjczNHUpPygsPyh1ODs0'), methods=[_wolf_s('ChUJDg==')]) @admin_required def admin_server_ban(): data = request.get_json(silent=True) or {} key = (data.get(_wolf_s('MT8j')) or _wolf_s('')).strip() banned = bool(data.get(_wolf_s('ODs0ND8+'), True)) owner, folder = parse_server_key(key, allow_admin=True) server_dir = get_server_dir(owner, folder) if not os.path.isdir(server_dir): return (jsonify({_wolf_s('KS85OT8pKQ=='): False, _wolf_s('Nz8pKTs9Pw=='): _wolf_s('CT8oLD8oejQ1Lno8NS80Pg==')}), 404) meta = read_meta(owner, folder) meta[_wolf_s('ODs0ND8+')] = banned write_meta(owner, folder, meta) if banned: stop_proc(key) set_state(key, _wolf_s('GDs0ND8+')) log_append(key, _wolf_s('ARseFxMUB3oJPygsPyh6ODs0ND8+dFA=')) else: set_state(key, _wolf_s('FTw8NjM0Pw==')) log_append(key, _wolf_s('ARseFxMUB3oJPygsPyh6LzQ4OzQ0Pz50UA==')) gw_touch(owner, folder, force=True) return jsonify({_wolf_s('KS85OT8pKQ=='): True}) _SKIP_UPSTREAM_HEADERS = {_wolf_s('OTU0Lj80Lnc2PzQ9LjI='), _wolf_s('OTU0Lj80Lnc/NDk1PjM0PQ=='), _wolf_s('Lig7NCk8Pyh3PzQ5NT4zND0='), _wolf_s('OTU0ND85LjM1NA=='), _wolf_s('MT8/Knc7NjMsPw==')} def _proxy_to_local(url: str): fwd = {} for h in (_wolf_s('OTU0Lj80LncuIyo/'), _wolf_s('OTU1MTM/'), _wolf_s('Ozk5Pyou'), _wolf_s('Ozk5Pyoudz80OTU+MzQ9'), _wolf_s('KDs0PT8='), _wolf_s('Mzx3NDU0P3c3Oy45Mg=='), _wolf_s('IncuPzY/PSg7N3c4NS53Oyozdyk/OSg/LncuNTE/NA==')): if h in request.headers: fwd[h] = request.headers[h] try: upstream = http.request(request.method, url, data=request.get_data() if request.method not in (_wolf_s('HR8O'), _wolf_s('Eh8bHg==')) else None, headers=fwd, allow_redirects=False, timeout=60, stream=False) except Exception as e: return (jsonify({_wolf_s('KS85OT8pKQ=='): False, _wolf_s('Nz8pKTs9Pw=='): f'site backend unavailable: {e}'}), 502) resp = make_response(upstream.content, upstream.status_code) for k, v in upstream.raw.headers.items(): if k.lower() in _SKIP_UPSTREAM_HEADERS or k.lower() == _wolf_s('OTU0Lj80LncuIyo/'): continue resp.headers.add(k, v) if (ct := upstream.headers.get(_wolf_s('OTU0Lj80LncuIyo/'))) is not None: resp.headers[_wolf_s('GTU0Lj80LncOIyo/')] = ct return resp def _process_listen_ports(key: str): out = set() tracked = running_procs.get(key) if tracked is None: want_folder = key.split(_wolf_s('YGA='))[-1] for k, v in running_procs.items(): if k == want_folder or k.endswith(_wolf_s('YGA=') + want_folder): tracked = v break if tracked is None: return out root = tracked[0] try: procs = [psutil.Process(root.pid)] procs += procs[0].children(recursive=True) except Exception: return out for p in procs: try: for c in p.connections(kind=_wolf_s('MzQ/Lg==')): if c.status == psutil.CONN_LISTEN and c.laddr: port = int(c.laddr.port) if port not in (7860, 7861, 7862): out.add(port) except Exception: continue return out def _rewrite_site_html(resp, sub: str): try: ct = resp.headers.get(_wolf_s('GTU0Lj80LncOIyo/'), _wolf_s('')) if _wolf_s('Lj8iLnUyLjc2') not in ct: return resp raw = resp.get_data() try: text = raw.decode(_wolf_s('Ly48d2I=')) except UnicodeDecodeError: return resp prefix = _wolf_s('dS0/OHU=') + sub for att in (_wolf_s('KSg5Zw=='), _wolf_s('Mig/PGc='), _wolf_s('OzkuMzU0Zw=='), _wolf_s('KSg5KT8uZw==')): for q in (_wolf_s('eA=='), _wolf_s('fQ==')): text = text.replace(att + q + _wolf_s('dQ=='), att + q + prefix + _wolf_s('dQ==')) text = text.replace(_wolf_s('Lyg2cnU='), _wolf_s('Lyg2cg==') + prefix + _wolf_s('dQ==')) resp.set_data(text.encode(_wolf_s('Ly48d2I='))) resp.headers.pop(_wolf_s('GTU0Lj80LncWPzQ9LjI='), None) return resp except Exception: return resp def _site_proxy_response(owner, folder, meta, rel, sub=_wolf_s('')): key = f'{owner}::{folder}' port = 0 try: port = int(meta.get(_wolf_s('KjUoLg==')) or 0) except Exception: port = 0 def _go(p: int): url = f'http://127.0.0.1:{p}/{rel}' if request.query_string: url += _wolf_s('ZQ==') + request.query_string.decode(_wolf_s('NjsuMzR3aw==')) return _proxy_to_local(url) if port: resp = _go(port) if isinstance(resp, tuple) and resp[0].status_code == 502: for alt in sorted(_process_listen_ports(key)): resp2 = _go(alt) if not (isinstance(resp2, tuple) and resp2[0].status_code == 502): meta[_wolf_s('KjUoLg==')] = alt write_meta(owner, folder, meta) return _rewrite_site_html(resp2, sub) if sub else resp2 return _rewrite_site_html(resp, sub) if sub else resp for alt in sorted(_process_listen_ports(key)): meta[_wolf_s('KjUoLg==')] = alt write_meta(owner, folder, meta) resp = _go(alt) return _rewrite_site_html(resp, sub) if sub else resp return (jsonify({_wolf_s('KS85OT8pKQ=='): False, _wolf_s('Nz8pKTs9Pw=='): _wolf_s('CT8oLD8oejI7KXo0NXo7NjY1OTsuPz56KjUoLnpyNDUuejt6MjUpLjM0PXouIyo/ZXM=')}), 400) @app.route(_wolf_s('dS0/OHVmKS84ZHU='), defaults={_wolf_s('KD82'): _wolf_s('')}, methods=[_wolf_s('HR8O'), _wolf_s('ChUJDg=='), _wolf_s('Cg8O'), _wolf_s('ChsOGRI='), _wolf_s('Hh8WHw4f'), _wolf_s('FQoOExUUCQ=='), _wolf_s('Eh8bHg==')]) @app.route(_wolf_s('dS0/OHVmKS84ZHVmKjsuMmAoPzZk'), methods=[_wolf_s('HR8O'), _wolf_s('ChUJDg=='), _wolf_s('Cg8O'), _wolf_s('ChsOGRI='), _wolf_s('Hh8WHw4f'), _wolf_s('FQoOExUUCQ=='), _wolf_s('Eh8bHg==')]) def web_site_proxy(sub, rel): found = find_server_by_subdomain(sub) if not found: return (jsonify({_wolf_s('KS85OT8pKQ=='): False, _wolf_s('Nz8pKTs9Pw=='): _wolf_s('FDV6KTMuP3o8NSh6LjI7LnopLzg+NTc7MzQ=')}), 404) owner, folder, meta = found if meta.get(_wolf_s('ODs0ND8+')): return (jsonify({_wolf_s('KS85OT8pKQ=='): False, _wolf_s('Nz8pKTs9Pw=='): _wolf_s('CTMuP3ozKXo4OzQ0Pz4=')}), 403) return _site_proxy_response(owner, folder, meta, rel, sub=sub) PANEL_API_KEY = os.environ.get(_wolf_s('ChsUHxYFGwoTBREfAw=='), _wolf_s('')).strip() def _api_key_ok() -> bool: import hmac as _hmac presented = request.headers.get(_wolf_s('AncbKjN3ET8j'), _wolf_s('')).strip() auth = request.headers.get(_wolf_s('Gy8uMjUoMyA7LjM1NA=='), _wolf_s('')).strip() if not presented and auth.lower().startswith(_wolf_s('OD87KD8oeg==')): presented = auth[7:].strip() if not presented: return False if PANEL_API_KEY and _hmac.compare_digest(presented, PANEL_API_KEY): return True return gwclient.check_api_key(presented) is not None _ALL_SCOPES = (_wolf_s('KD87Pg=='), _wolf_s('OSg/Oy4/'), _wolf_s('PDM2Pyk='), _wolf_s('OTU0Lig1Ng=='), _wolf_s('Oz43MzQ=')) def _api_scopes(): import hmac as _hmac presented = request.headers.get(_wolf_s('AncbKjN3ET8j'), _wolf_s('')).strip() auth = request.headers.get(_wolf_s('Gy8uMjUoMyA7LjM1NA=='), _wolf_s('')).strip() if not presented and auth.lower().startswith(_wolf_s('OD87KD8oeg==')): presented = auth[7:].strip() if not presented: return None if PANEL_API_KEY and _hmac.compare_digest(presented, PANEL_API_KEY): return list(_ALL_SCOPES) return gwclient.check_api_key(presented) def _api_auth_or_fail(scope: str=_wolf_s('KD87Pg==')): presented = request.headers.get(_wolf_s('AncbKjN3ET8j'), _wolf_s('')).strip() auth = request.headers.get(_wolf_s('Gy8uMjUoMyA7LjM1NA=='), _wolf_s('')).strip() if not presented and auth.lower().startswith(_wolf_s('OD87KD8oeg==')): presented = auth[7:].strip() if not presented: return (jsonify({_wolf_s('KS85OT8pKQ=='): False, _wolf_s('Nz8pKTs9Pw=='): _wolf_s('GwoTejE/I3ooPysvMyg/Pg==')}), 401) scopes = _api_scopes() if scopes is None: return (jsonify({_wolf_s('KS85OT8pKQ=='): False, _wolf_s('Nz8pKTs9Pw=='): _wolf_s('EzQsOzYzPno1KHooPyw1MT8+ehsKE3oxPyM=')}), 401) if scope != _wolf_s('KD87Pg==') and _wolf_s('Oz43MzQ=') not in scopes and (scope not in scopes): return (jsonify({_wolf_s('KS85OT8pKQ=='): False, _wolf_s('Nz8pKTs9Pw=='): f'Missing scope: {scope}'}), 403) if scope == _wolf_s('KD87Pg==') and _wolf_s('Oz43MzQ=') not in scopes and (_wolf_s('KD87Pg==') not in scopes): return (jsonify({_wolf_s('KS85OT8pKQ=='): False, _wolf_s('Nz8pKTs9Pw=='): _wolf_s('FzMpKTM0PXopOTUqP2B6KD87Pg==')}), 403) return None @app.route(_wolf_s('dTsqM3Usa3UpPygsPygp'), methods=[_wolf_s('HR8O'), _wolf_s('ChUJDg==')]) def api_v1_servers(): need = _wolf_s('OSg/Oy4/') if request.method == _wolf_s('ChUJDg==') else _wolf_s('KD87Pg==') err = _api_auth_or_fail(need) if err: return err if request.method == _wolf_s('ChUJDg=='): return api_v1_create_server_body() out = [] for owner, folder, meta in list_all_metas(): out.append({_wolf_s('NS00Pyg='): owner, _wolf_s('PDU2Pj8o'): folder, _wolf_s('PjMpKjY7IwU0Ozc/'): meta.get(_wolf_s('PjMpKjY7IwU0Ozc/'), folder), _wolf_s('LiMqPw=='): meta.get(_wolf_s('LiMqPw=='), _wolf_s('KiMuMjU0')), _wolf_s('KS84PjU3OzM0'): meta.get(_wolf_s('KS84PjU3OzM0'), _wolf_s('')), _wolf_s('KS47KC4vKgU8MzY/'): meta.get(_wolf_s('KS47KC4vKgU8MzY/'), _wolf_s('')), _wolf_s('ODs0ND8+'): bool(meta.get(_wolf_s('ODs0ND8+'))), _wolf_s('KS47Li8p'): get_state(folder) if get_state(folder) != _wolf_s('FTw8NjM0Pw==') else get_state(f'{owner}::{folder}')}) return jsonify({_wolf_s('KS85OT8pKQ=='): True, _wolf_s('KT8oLD8oKQ=='): out}) @app.route(_wolf_s('dTsqM3Usa3UpPygsPyh1Zio7LjJgMT8jZA==')) def api_v1_server(key): err = _api_auth_or_fail(_wolf_s('KD87Pg==')) if err: return err kf = _api_key_from_path(key) if not kf: return (jsonify({_wolf_s('KS85OT8pKQ=='): False, _wolf_s('Nz8pKTs9Pw=='): _wolf_s('EzQsOzYzPnoxPyN6ci8pP3o1LTQ/KGBgPDU2Pj8ocw==')}), 400) owner, folder = kf if not os.path.isdir(get_server_dir(owner, folder)): return (jsonify({_wolf_s('KS85OT8pKQ=='): False, _wolf_s('Nz8pKTs9Pw=='): _wolf_s('FDUuejw1LzQ+')}), 404) meta = read_meta(owner, folder) st = get_state(f'{owner}::{folder}') if st == _wolf_s('FTw8NjM0Pw=='): st = get_state(folder) if get_state(folder) != _wolf_s('FTw8NjM0Pw==') else st meta[_wolf_s('KS47Li8p')] = st return jsonify({_wolf_s('KS85OT8pKQ=='): True, _wolf_s('KT8oLD8o'): meta}) @app.route(_wolf_s('dTsqM3Usa3UpPygsPyh1Zio7LjJgMT8jZHU7OS4zNTQ='), methods=[_wolf_s('ChUJDg==')]) def api_v1_server_action(key): err = _api_auth_or_fail(_wolf_s('OTU0Lig1Ng==')) if err: return err try: owner, folder = key.split(_wolf_s('YGA='), 1) except ValueError: owner = request.headers.get(_wolf_s('AncKOzQ/NncPKT8o'), _wolf_s('')).strip() folder = key.strip() if not owner: return (jsonify({_wolf_s('KS85OT8pKQ=='): False, _wolf_s('Nz8pKTs9Pw=='): _wolf_s('MT8jejcvKS56OD96NS00PyhgYDw1Nj4/KA==')}), 400) data = request.get_json(silent=True) or {} act = (data.get(_wolf_s('Ozku')) or _wolf_s('')).lower() if act not in (_wolf_s('KS47KC4='), _wolf_s('KS41Kg=='), _wolf_s('KD8pLjsoLg==')): return (jsonify({_wolf_s('KS85OT8pKQ=='): False, _wolf_s('Nz8pKTs9Pw=='): _wolf_s('OzkuejcvKS56OD96KS47KC4mKS41KiYoPykuOygu')}), 400) if act in (_wolf_s('KS41Kg=='), _wolf_s('KD8pLjsoLg==')): stop_proc(key) stop_proc(folder) stop_proc(f'{owner}::{folder}') set_state(key, _wolf_s('FTw8NjM0Pw==')) set_state(folder, _wolf_s('FTw8NjM0Pw==')) set_state(f'{owner}::{folder}', _wolf_s('FTw8NjM0Pw==')) if act == _wolf_s('KS41Kg=='): return jsonify({_wolf_s('KS85OT8pKQ=='): True}) server_dir = get_server_dir(owner, folder) meta = read_meta(owner, folder) startup = meta.get(_wolf_s('KS47KC4vKgU8MzY/')) or _wolf_s('') if not startup: candidates = [_wolf_s('MzQ+PyJ0KjIq'), _wolf_s('NzszNHQqMio='), _wolf_s('ODUudCoyKg==')] if meta.get(_wolf_s('LiMqPw==')) == _wolf_s('KjIq') else [_wolf_s('NzszNHQqIw=='), _wolf_s('ODUudCoj'), _wolf_s('OyoqdCoj'), _wolf_s('KC80dCoj'), _wolf_s('KS47KC50KiM=')] for c in candidates: if os.path.exists(os.path.join(server_dir, c)): startup = c break if not startup: return (jsonify({_wolf_s('KS85OT8pKQ=='): False, _wolf_s('Nz8pKTs9Pw=='): _wolf_s('FDV6KS47KC4vKno8MzY/')}), 400) full_key = f'{owner}::{folder}' _starting_keys.add(full_key) t = threading.Thread(target=background_start, args=(full_key, owner, folder, startup), daemon=True) t.start() return jsonify({_wolf_s('KS85OT8pKQ=='): True}) @app.route(_wolf_s('dTsqM3Usa3UyPzs2LjI=')) def api_v1_health(): err = _api_auth_or_fail(_wolf_s('KD87Pg==')) if err: return err return jsonify({_wolf_s('KS85OT8pKQ=='): True, _wolf_s('KjIq'): bool(shutil.which(_wolf_s('KjIq'))), _wolf_s('KT8oLD8oKQ=='): len(list_all_metas())}) @app.route(_wolf_s('dTsqM3Usa3U+NTkp')) def api_v1_docs(): txt = _wolf_s('DTU2PHoSNSkuerjaznoKLzg2Mzl6CjY7Ljw1KDd6GwoTenJ1OyozdSxrc1BnZ2dnZ2dnZ2dnZ2dnZ2dnZ2dnZ2dnZ2dnZ2dnZ2dnZ2dnZ2dnZ2dnZ1AbLy4yYHo/LD8oI3ooPysvPykuejQ/Pz4pejI/Oz4/KHp6AncbKjN3ET8jYHpmChsUHxYFGwoTBREfA2RQGzY2eig/Ky8/KS4pejsoP3ooOy4/dzYzNzMuPz56OzQ+ejY1PT0/PnR6CD8pKjU0KT8pejsoP3oQCRUUdFBQHzQ+KjUzNC4pUHd3d3d3d3d3d1AdHw56enU7KjN1LGt1Mj87Ni4yUB0fDnp6dTsqM3Usa3UpPygsPygpUAoVCQ56dTsqM3Usa3UpPygsPygpenp6enp6enp6enp6enp6enp6enp6eiE0Ozc/dnouIyo/ZXZ6KS84PjU3OzM0ZXZ6KS47KC4vKgU8MzY/ZSdQHR8Oenp1OyozdSxrdSk/KCw/KHVmMT8jZFAKFQkOenU7KjN1LGt1KT8oLD8odWYxPyNkdTs5LjM1NHp6enp6enp6enohOzkuYHopLjsoLiYpLjUqJig/KS47KC4nUAoVCQ56dTsqM3Usa3UpPygsPyh1ZjE/I2R1KT8udykuOyguLyp6enp6eiE8MzY/J1AKFQkOenU7KjN1LGt1KT8oLD8odWYxPyNkdTwzNj8penp6enp6enp6enohKjsuMnZ6OTU0Lj80LgU4Oyk/bG4nenpyNSh6ITk1NC4/NC4nemd6Ly48d2J6Lj8iLnNQHR8Oenp1OyozdSxrdSk/KCw/KHVmMT8jZHU8MzY/KWUqOy4yZyg/Nnp6NjMpLlAdHw56enU7KjN1LGt1KT8oLD8odWYxPyNkdTwzNj9lKjsuMmcoPzZ6enooPzs+ejU0P3o8MzY/UAoVCQ56dTsqM3Usa3UpPygsPyh1ZjE/I2R1Lyo2NTs+enp6enp6enp6ejcvNi4zKjsoLno8NSg3YHo8MzY/KQEHenF6KD82KjsuMikBB1AdHw56enU7KjN1LGt1KT8oLD8odWYxPyNkdTY1PVBQZjE/I2R6Z3o1LTQ/KGBgPDU2Pj8oenpyNSh6KjY7MzR6PDU2Pj8oenF6AncKOzQ/NncPKT8oejI/Oz4/KHNQLiMqP3p6Z3oqIy4yNTR6JnotPzg7Kip6Jno7KjN6JnoqMip6enp6eno+Pzw7LzYuYHoqIy4yNTRQUBs8Lj8oejt6KD84NTUuei4yP3oqNjsuPDUoN3o7Ly41NzsuMzk7NjYjeig/KS41KD8pej8sPygjeik/KCw/KHo7ND5QKD8pLjsoLil6LjI/ejU0Pyl6LjI7LnotPyg/eggvNDQzND11CS47KC4zND11EzQpLjs2NjM0PXpyNTR6OCN6Pj88Oy82LnN0UA==') return (txt, 200, {_wolf_s('GTU0Lj80LncOIyo/'): _wolf_s('Lj8iLnUqNjszNGF6OTI7KCk/LmcvLjx3Yg=='), _wolf_s('GTs5Mj93GTU0Lig1Ng=='): _wolf_s('NDV3KS41KD8=')}) def _api_key_from_path(key): key = (key or _wolf_s('')).strip() try: if _wolf_s('YGA=') in key: owner, folder = key.split(_wolf_s('YGA='), 1) owner, folder = (owner.strip(), folder.strip()) if not owner or not folder: return None if not re.match(_wolf_s('BAE7dyAbdwBqd2MFdHcHcX4='), owner) or not re.match(_wolf_s('BAE7dyAbdwBqd2MFdHcHcX4='), folder): return None return (owner, folder) owner = request.headers.get(_wolf_s('AncKOzQ/NncPKT8o'), _wolf_s('')).strip() if not owner and (not re.match(_wolf_s('BAE7dyAbdwBqd2MFdHcHcX4='), key)): return None if not owner: return None return (owner, key) except Exception: return None def api_v1_create_server_body(): data = request.get_json(silent=True) or {} name = (data.get(_wolf_s('NDs3Pw==')) or _wolf_s('')).strip() owner = (data.get(_wolf_s('NS00Pyg=')) or _wolf_s('')).strip() or current_username_fallback() folder = sanitize_folder_name(name) if not folder or not owner: return (jsonify({_wolf_s('KS85OT8pKQ=='): False, _wolf_s('Nz8pKTs9Pw=='): _wolf_s('NDs3P3o7ND56NS00Pyh6KD8rLzMoPz4=')}), 400) server_type = (data.get(_wolf_s('LiMqPw==')) or _wolf_s('KiMuMjU0')).lower() if server_type not in SERVER_TYPES: return (jsonify({_wolf_s('KS85OT8pKQ=='): False, _wolf_s('Nz8pKTs9Pw=='): _wolf_s('ODs+ei4jKj8=')}), 400) subdomain = normalize_subdomain(data.get(_wolf_s('KS84PjU3OzM0')) or _wolf_s('')) if server_type in (_wolf_s('LT84Oyoq'), _wolf_s('Oyoz'), _wolf_s('KjIq')): if not subdomain: subdomain = normalize_subdomain(folder) while subdomain_taken(subdomain): subdomain = subdomain + _wolf_s('dyI=') ensure_user_dirs(owner) target = get_server_dir(owner, folder) if os.path.exists(target): return (jsonify({_wolf_s('KS85OT8pKQ=='): False, _wolf_s('Nz8pKTs9Pw=='): _wolf_s('PyIzKS4p')}), 409) os.makedirs(target, exist_ok=True) open(os.path.join(target, _wolf_s('KT8oLD8odDY1PQ==')), _wolf_s('LQ=='), encoding=_wolf_s('Ly48d2I=')).close() meta = {_wolf_s('PjMpKjY7IwU0Ozc/'): name[:80], _wolf_s('KS47KC4vKgU8MzY/'): data.get(_wolf_s('KS47KC4vKgU8MzY/'), _wolf_s('')), _wolf_s('NS00Pyg='): owner, _wolf_s('ODs0ND8+'): False, _wolf_s('LiMqPw=='): server_type, _wolf_s('KS84PjU3OzM0'): subdomain, _wolf_s('KjUoLg=='): allocate_port() if server_type in (_wolf_s('LT84Oyoq'), _wolf_s('Oyoz'), _wolf_s('KjIq')) else 0} write_meta(owner, folder, meta) return jsonify({_wolf_s('KS85OT8pKQ=='): True, _wolf_s('KT8oLD8o'): {_wolf_s('NS00Pyg='): owner, _wolf_s('PDU2Pj8o'): folder, _wolf_s('MT8j'): f'{owner}::{folder}', _wolf_s('KS84PjU3OzM0'): subdomain, _wolf_s('LiMqPw=='): server_type}}) def current_username_fallback(): u = request.headers.get(_wolf_s('AncKOzQ/NncPKT8o'), _wolf_s('')).strip() return u def _api_write_file(owner, folder, rel, raw: bytes): server_root = get_server_dir(owner, folder) if not rel or _wolf_s('dHQ=') in rel.replace(_wolf_s('Bg=='), _wolf_s('dQ==')).split(_wolf_s('dQ==')): raise ValueError(_wolf_s('ODs+eio7LjI=')) target = os.path.realpath(os.path.join(server_root, rel)) if not (target == os.path.realpath(server_root) or target.startswith(os.path.realpath(server_root) + os.sep)): raise ValueError(_wolf_s('Lig7LD8oKTs2')) os.makedirs(os.path.dirname(target) or server_root, exist_ok=True) with open(target, _wolf_s('LTg=')) as f: f.write(raw) @app.route(_wolf_s('dTsqM3Usa3UpPygsPyh1Zio7LjJgMT8jZHU8MzY/KQ=='), methods=[_wolf_s('HR8O'), _wolf_s('ChUJDg==')]) def api_v1_files(key): err = _api_auth_or_fail(_wolf_s('KD87Pg==') if request.method == _wolf_s('HR8O') else _wolf_s('PDM2Pyk=')) if err: return err kf = _api_key_from_path(key) if not kf: return (jsonify({_wolf_s('KS85OT8pKQ=='): False, _wolf_s('Nz8pKTs9Pw=='): _wolf_s('EzQsOzYzPnoxPyM=')}), 400) owner, folder = kf if request.method == _wolf_s('HR8O'): rel = request.args.get(_wolf_s('KjsuMg=='), _wolf_s('')) or _wolf_s('') base = os.path.realpath(os.path.join(get_server_dir(owner, folder), rel.lstrip(_wolf_s('dQY=')))) if not os.path.isdir(base): return (jsonify({_wolf_s('KS85OT8pKQ=='): False, _wolf_s('Nz8pKTs9Pw=='): _wolf_s('FDUuejt6PjMo')}), 400) items = [] for n in sorted(os.listdir(base)): full = os.path.join(base, n) items.append({_wolf_s('NDs3Pw=='): n, _wolf_s('PjMo'): os.path.isdir(full), _wolf_s('KTMgPw=='): os.path.getsize(full) if os.path.isfile(full) else 0}) return jsonify({_wolf_s('KS85OT8pKQ=='): True, _wolf_s('My4/Nyk='): items, _wolf_s('KjsuMg=='): rel}) data = request.get_json(silent=True) or {} rel = (data.get(_wolf_s('KjsuMg==')) or _wolf_s('')).strip() try: if _wolf_s('OTU0Lj80LgU4Oyk/bG4=') in data: raw = base64.b64decode(data[_wolf_s('OTU0Lj80LgU4Oyk/bG4=')]) else: raw = str(data.get(_wolf_s('OTU0Lj80Lg=='), _wolf_s(''))).encode(_wolf_s('Ly48d2I=')) _api_write_file(owner, folder, rel, raw) except Exception as e: return (jsonify({_wolf_s('KS85OT8pKQ=='): False, _wolf_s('Nz8pKTs9Pw=='): str(e)}), 400) try: gw_touch(owner, folder, force=True) except Exception: pass return jsonify({_wolf_s('KS85OT8pKQ=='): True, _wolf_s('KjsuMg=='): rel, _wolf_s('OCMuPyk='): len(raw)}) @app.route(_wolf_s('dTsqM3Usa3UpPygsPyh1Zio7LjJgMT8jZHU8MzY/')) def api_v1_read_file(key): err = _api_auth_or_fail(_wolf_s('KD87Pg==')) if err: return err kf = _api_key_from_path(key) if not kf: return (jsonify({_wolf_s('KS85OT8pKQ=='): False, _wolf_s('Nz8pKTs9Pw=='): _wolf_s('EzQsOzYzPnoxPyM=')}), 400) owner, folder = kf rel = request.args.get(_wolf_s('KjsuMg=='), _wolf_s('')) try: target = os.path.realpath(os.path.join(get_server_dir(owner, folder), rel.lstrip(_wolf_s('dQY=')))) root = os.path.realpath(get_server_dir(owner, folder)) if not target.startswith(root + os.sep) or not os.path.isfile(target): raise ValueError(_wolf_s('NDUuejw1LzQ+')) with open(target, _wolf_s('KDg=')) as f: raw = f.read() except Exception: return (jsonify({_wolf_s('KS85OT8pKQ=='): False, _wolf_s('Nz8pKTs9Pw=='): _wolf_s('FDUuejw1LzQ+')}), 404) return jsonify({_wolf_s('KS85OT8pKQ=='): True, _wolf_s('KjsuMg=='): rel, _wolf_s('OTU0Lj80LgU4Oyk/bG4='): base64.b64encode(raw).decode(_wolf_s('Oyk5MzM='))}) @app.route(_wolf_s('dTsqM3Usa3UpPygsPyh1Zio7LjJgMT8jZHUvKjY1Oz4='), methods=[_wolf_s('ChUJDg==')]) def api_v1_upload(key): err = _api_auth_or_fail(_wolf_s('PDM2Pyk=')) if err: return err kf = _api_key_from_path(key) if not kf: return (jsonify({_wolf_s('KS85OT8pKQ=='): False, _wolf_s('Nz8pKTs9Pw=='): _wolf_s('EzQsOzYzPnoxPyM=')}), 400) owner, folder = kf files = request.files.getlist(_wolf_s('PDM2Pyk=')) or request.files.getlist(_wolf_s('PDM2Pw==')) relpaths = request.form.getlist(_wolf_s('KD82KjsuMik=')) saved = 0 try: for i, f in enumerate(files): rel = relpaths[i] if i < len(relpaths) and relpaths[i] else f.filename _api_write_file(owner, folder, rel, f.read()) saved += 1 except Exception as e: return (jsonify({_wolf_s('KS85OT8pKQ=='): False, _wolf_s('Nz8pKTs9Pw=='): str(e)}), 400) try: gw_touch(owner, folder, force=True) except Exception: pass return jsonify({_wolf_s('KS85OT8pKQ=='): True, _wolf_s('KTssPz4='): saved}) @app.route(_wolf_s('dTsqM3Usa3UpPygsPyh1Zio7LjJgMT8jZHUpPy53KS47KC4vKg=='), methods=[_wolf_s('ChUJDg==')]) def api_v1_set_startup(key): err = _api_auth_or_fail(_wolf_s('PDM2Pyk=')) if err: return err kf = _api_key_from_path(key) if not kf: return (jsonify({_wolf_s('KS85OT8pKQ=='): False, _wolf_s('Nz8pKTs9Pw=='): _wolf_s('EzQsOzYzPnoxPyM=')}), 400) owner, folder = kf data = request.get_json(silent=True) or {} f = (data.get(_wolf_s('PDM2Pw==')) or _wolf_s('')).strip() meta = read_meta(owner, folder) meta[_wolf_s('KS47KC4vKgU8MzY/')] = f write_meta(owner, folder, meta) return jsonify({_wolf_s('KS85OT8pKQ=='): True}) @app.route(_wolf_s('dTsqM3Usa3UpPygsPyh1Zio7LjJgMT8jZHU2NT0=')) def api_v1_log(key): err = _api_auth_or_fail(_wolf_s('KD87Pg==')) if err: return err kf = _api_key_from_path(key) if not kf: return (jsonify({_wolf_s('KS85OT8pKQ=='): False, _wolf_s('Nz8pKTs9Pw=='): _wolf_s('EzQsOzYzPnoxPyM=')}), 400) owner, folder = kf p = os.path.join(get_server_dir(owner, folder), _wolf_s('KT8oLD8odDY1PQ==')) try: with open(p, _wolf_s('KA=='), encoding=_wolf_s('Ly48d2I='), errors=_wolf_s('Mz00NSg/')) as f: tail = f.read()[-20000:] except Exception: tail = _wolf_s('') return jsonify({_wolf_s('KS85OT8pKQ=='): True, _wolf_s('NjU9'): tail}) @app.route(_wolf_s('dWYqOy4yYCg/NmQ='), methods=[_wolf_s('HR8O'), _wolf_s('ChUJDg=='), _wolf_s('Cg8O'), _wolf_s('ChsOGRI='), _wolf_s('Hh8WHw4f'), _wolf_s('FQoOExUUCQ=='), _wolf_s('Eh8bHg==')]) def zerogpu_gradio_proxy(rel: str): site = request.headers.get(_wolf_s('AncKOzQ/NncJMy4/'), _wolf_s('')) if site: try: owner, folder = site.split(_wolf_s('dQ=='), 1) except ValueError: return (jsonify({_wolf_s('KS85OT8pKQ=='): False, _wolf_s('Nz8pKTs9Pw=='): _wolf_s('GDs+eikzLj96Mj87Pj8o')}), 400) try: meta = read_meta(owner, folder) except Exception: return (jsonify({_wolf_s('KS85OT8pKQ=='): False, _wolf_s('Nz8pKTs9Pw=='): _wolf_s('DzQxNDUtNHopMy4/')}), 404) if meta.get(_wolf_s('ODs0ND8+')): return (jsonify({_wolf_s('KS85OT8pKQ=='): False, _wolf_s('Nz8pKTs9Pw=='): _wolf_s('CTMuP3ozKXo4OzQ0Pz4=')}), 403) return _site_proxy_response(owner, folder, meta, rel) url = f'http://127.0.0.1:{PROBE_PORT}/{rel}' if request.query_string: url += _wolf_s('ZQ==') + request.query_string.decode(_wolf_s('NjsuMzR3aw==')) fwd = {} for h in (_wolf_s('OTU0Lj80LncuIyo/'), _wolf_s('OTU1MTM/'), _wolf_s('Ozk5Pyou')): if h in request.headers: fwd[h] = request.headers[h] try: upstream = http.request(request.method, url, data=request.get_data() if request.method not in (_wolf_s('HR8O'), _wolf_s('Eh8bHg==')) else None, headers=fwd, allow_redirects=False, timeout=30) except Exception as e: return (jsonify({_wolf_s('KS85OT8pKQ=='): False, _wolf_s('Nz8pKTs9Pw=='): f'probe backend unavailable: {e}'}), 502) resp = make_response(upstream.content, upstream.status_code) for k, v in upstream.raw.headers.items(): if k.lower() in _SKIP_UPSTREAM_HEADERS or k.lower() == _wolf_s('OTU0Lj80LncuIyo/'): continue resp.headers.add(k, v) if (ct := upstream.headers.get(_wolf_s('OTU0Lj80LncuIyo/'))) is not None: resp.headers[_wolf_s('GTU0Lj80LncOIyo/')] = ct return resp PANEL_SYNC_EVERY = int(os.environ.get(_wolf_s('ChsUHxYFCQMUGQUfDB8IAw=='), _wolf_s('bGo='))) PANEL_SNAPSHOT_EVERY = int(os.environ.get(_wolf_s('ChsUHxYFCRQbCgkSFQ4FHwwfCAM='), _wolf_s('bGpq'))) PANEL_MAX_FILE = int(os.environ.get(_wolf_s('ChsUHxYFFxsCBQkDFBkFHBMWHwUXGA=='), _wolf_s('bw=='))) * 1024 * 1024 PANEL_LOG_TAIL = 60 * 1024 PANEL_STAT_BATCH = 3 SYNC_STATE_PATH = os.path.join(DATA_DIR, _wolf_s('dCkjNDkFKS47Lj90MCk1NA==')) _SYNC_SKIP_DIRS = {_wolf_s('BQUqIzk7OTI/BQU='), _wolf_s('dD0zLg=='), _wolf_s('NDU+PwU3NT4vNj8p')} _SYNC_SKIP_FILES = {_wolf_s('KT8oLD8odDY1PQ==')} _SYNC_SKIP_SUFFIXES = (_wolf_s('dD44dy07Ng=='), _wolf_s('dD44dykyNw=='), _wolf_s('dD44dzA1Lyg0OzY='), _wolf_s('dCkrNjMuP3ctOzY='), _wolf_s('dCkrNjMuP3cpMjc=')) LOCAL_IP = get_ip() def _load_sync_state(): try: with open(SYNC_STATE_PATH, encoding=_wolf_s('Ly48d2I=')) as f: return json.load(f) or {} except Exception: return {} def _save_sync_state(state): try: os.makedirs(DATA_DIR, exist_ok=True) tmp = SYNC_STATE_PATH + _wolf_s('dC43Kg==') with open(tmp, _wolf_s('LQ=='), encoding=_wolf_s('Ly48d2I=')) as f: json.dump(state, f) os.replace(tmp, SYNC_STATE_PATH) except Exception as e: print(f'[sync] state save failed: {e}', flush=True) def _sha_bytes(data: bytes) -> str: return hashlib.sha256(data).hexdigest() def _sha_text(text: str) -> str: return hashlib.sha256(text.encode(_wolf_s('Ly48d2I='), _wolf_s('KD8qNjs5Pw=='))).hexdigest() def _read_log_tail(path: str) -> str: try: size = os.path.getsize(path) with open(path, _wolf_s('KDg=')) as f: if size > PANEL_LOG_TAIL: f.seek(size - PANEL_LOG_TAIL) data = f.read() return data.decode(_wolf_s('Ly48d2I='), _wolf_s('KD8qNjs5Pw==')) except OSError: return _wolf_s('') def _lookup_state(owner: str, folder: str) -> str: with lock: st = server_states.get(f'{owner}::{folder}') or server_states.get(folder) return st or _wolf_s('FTw8NjM0Pw==') def _scan_local(hashes: bool=True): out = {} if not os.path.isdir(USERS_ROOT): return out for owner in sorted(os.listdir(USERS_ROOT)): root = get_user_servers_root(owner) if not os.path.isdir(root): continue for folder in sorted(os.listdir(root)): sdir = get_server_dir(owner, folder) if not os.path.isdir(sdir): continue files = {} if hashes: for dirpath, dirnames, filenames in os.walk(sdir): dirnames[:] = sorted((d for d in dirnames if d not in _SYNC_SKIP_DIRS)) for name in sorted(filenames): if name in _SYNC_SKIP_FILES or name.endswith(_wolf_s('dCojOQ==')) or name.endswith(_SYNC_SKIP_SUFFIXES): continue p = os.path.join(dirpath, name) rel = os.path.relpath(p, sdir).replace(_wolf_s('Bg=='), _wolf_s('dQ==')) try: size = os.path.getsize(p) except OSError: continue if size > PANEL_MAX_FILE: files[rel] = {_wolf_s('KD82'): rel, _wolf_s('KTI7'): _wolf_s(''), _wolf_s('KjsuMg=='): p, _wolf_s('KTMgPw=='): size, _wolf_s('KTEzKg=='): True} continue try: with open(p, _wolf_s('KDg=')) as f: files[rel] = {_wolf_s('KD82'): rel, _wolf_s('KTI7'): _sha_bytes(f.read()), _wolf_s('KjsuMg=='): p, _wolf_s('KTMgPw=='): size} except OSError: continue out[f'{owner}::{folder}'] = {_wolf_s('NS00Pyg='): owner, _wolf_s('PDU2Pj8o'): folder, _wolf_s('Nz8uOw=='): read_meta(owner, folder), _wolf_s('PDM2Pyk='): files} return out def _meta_differs(local_meta, remote_meta): lm, rm = (local_meta or {}, remote_meta or {}) return (lm.get(_wolf_s('PjMpKjY7IwU0Ozc/')) or _wolf_s('')) != (rm.get(_wolf_s('PjMpKjY7IwU0Ozc/')) or _wolf_s('')) or (lm.get(_wolf_s('KS47KC4vKgU8MzY/')) or _wolf_s('')) != (rm.get(_wolf_s('KS47KC4vKgU8MzY/')) or _wolf_s('')) or bool(lm.get(_wolf_s('ODs0ND8+'))) != bool(rm.get(_wolf_s('ODs0ND8+'))) or ((lm.get(_wolf_s('LiMqPw==')) or _wolf_s('KiMuMjU0')) != (rm.get(_wolf_s('LiMqPw==')) or _wolf_s('KiMuMjU0'))) or ((lm.get(_wolf_s('KS84PjU3OzM0')) or _wolf_s('')) != (rm.get(_wolf_s('KS84PjU3OzM0')) or _wolf_s(''))) or (int(lm.get(_wolf_s('KjUoLg==')) or 0) != int(rm.get(_wolf_s('KjUoLg==')) or 0)) def _remote_meta(meta, folder): meta = meta or {} return {_wolf_s('PjMpKjY7IwU0Ozc/'): meta.get(_wolf_s('PjMpKjY7IwU0Ozc/')) or folder, _wolf_s('KS47KC4vKgU8MzY/'): meta.get(_wolf_s('KS47KC4vKgU8MzY/')) or _wolf_s(''), _wolf_s('ODs0ND8+'): bool(meta.get(_wolf_s('ODs0ND8+'), False)), _wolf_s('LiMqPw=='): meta.get(_wolf_s('LiMqPw==')) or _wolf_s('KiMuMjU0'), _wolf_s('KS84PjU3OzM0'): meta.get(_wolf_s('KS84PjU3OzM0')) or _wolf_s(''), _wolf_s('KjUoLg=='): int(meta.get(_wolf_s('KjUoLg==')) or 0)} def get_server_cpu_mem(owner: str, folder: str) -> tuple: key = f'{owner}::{folder}' proc_tuple = running_procs.get(key) if not proc_tuple: return (_wolf_s('an8='), _wolf_s('anoXGA==')) proc, _logf = proc_tuple try: if not psutil.pid_exists(proc.pid): return (_wolf_s('an8='), _wolf_s('anoXGA==')) p = psutil.Process(proc.pid) if p.is_running() and p.status() != psutil.STATUS_ZOMBIE: return (f'{p.cpu_percent(interval=None)}%', f'{p.memory_info().rss / 1024 / 1024:.1f} MB') except Exception: pass return (_wolf_s('an8='), _wolf_s('anoXGA==')) def gw_push_stats(): if not gwclient.gateway_available(): return local = _scan_local(hashes=False) if not local: return state = _load_sync_state() log_hashes = state.get(_wolf_s('BQU2NT0p')) if isinstance(state.get(_wolf_s('BQU2NT0p')), dict) else {} new_log_hashes = {} items = [] for key, info in local.items(): owner, folder = (info[_wolf_s('NS00Pyg=')], info[_wolf_s('PDU2Pj8o')]) meta = info[_wolf_s('Nz8uOw==')] banned = bool(meta.get(_wolf_s('ODs0ND8+'))) status = _wolf_s('GDs0ND8+') if banned else _lookup_state(owner, folder) cpu, mem = (_wolf_s('an8='), _wolf_s('anoXGA==')) if status == _wolf_s('CC80NDM0PQ=='): try: cpu, mem = get_server_cpu_mem(owner, folder) except Exception: pass log = _read_log_tail(os.path.join(get_server_dir(owner, folder), _wolf_s('KT8oLD8odDY1PQ=='))) log_sha = _sha_text(log) new_log_hashes[key] = log_sha item = {_wolf_s('NS00Pyg='): owner, _wolf_s('PDU2Pj8o'): folder, _wolf_s('KS47Lik='): {_wolf_s('KS47Li8p'): status, _wolf_s('OSov'): cpu, _wolf_s('Nz83'): mem, _wolf_s('Myo='): LOCAL_IP}, _wolf_s('Nz8uOw=='): _remote_meta(meta, folder)} if log_sha != log_hashes.get(key): item[_wolf_s('NjU9')] = log items.append(item) ok = True for i in range(0, len(items), PANEL_STAT_BATCH): if not _gw_push_stat_chunk(items[i:i + PANEL_STAT_BATCH]): ok = False if ok: state[_wolf_s('BQU2NT0p')] = new_log_hashes _save_sync_state(state) def _gw_push_stat_chunk(chunk): try: gwclient.gw_call(_wolf_s('ChUJDg=='), _wolf_s('dTM0Lj8oNDs2dSovKTI='), {_wolf_s('My4/Nyk='): chunk}, timeout=25, retries=1) return True except Exception as e: if len(chunk) > 1: mid = len(chunk) // 2 print(f'[sync:stats] batch rejected, splitting {len(chunk)} -> {mid}+{len(chunk) - mid}: {e}', flush=True) first = _gw_push_stat_chunk(chunk[:mid]) second = _gw_push_stat_chunk(chunk[mid:]) return first and second print(f'[sync:stats] failed: {e}', flush=True) return False _last_pushed_status = {} def gw_touch(owner: str, folder: str, force: bool=False): if not gwclient.gateway_available(): return key = f'{owner}::{folder}' try: meta = read_meta(owner, folder) except Exception: meta = {} status = _wolf_s('GDs0ND8+') if meta.get(_wolf_s('ODs0ND8+')) else _lookup_state(owner, folder) if not force and _last_pushed_status.get(key) == status: return cpu, mem = (_wolf_s('an8='), _wolf_s('anoXGA==')) if status == _wolf_s('CC80NDM0PQ=='): try: cpu, mem = get_server_cpu_mem(owner, folder) except Exception: pass item = {_wolf_s('NS00Pyg='): owner, _wolf_s('PDU2Pj8o'): folder, _wolf_s('KS47Lik='): {_wolf_s('KS47Li8p'): status, _wolf_s('OSov'): cpu, _wolf_s('Nz83'): mem, _wolf_s('Myo='): LOCAL_IP}, _wolf_s('Nz8uOw=='): _remote_meta(meta, folder)} try: gwclient.gw_call(_wolf_s('ChUJDg=='), _wolf_s('dTM0Lj8oNDs2dSovKTI='), {_wolf_s('My4/Nyk='): [item]}, timeout=8, retries=1) _last_pushed_status[key] = status except Exception as e: print(f'[gw] touch({key}) failed: {e}', flush=True) def gw_reconcile(): if not gwclient.gateway_available(): return False try: boot = gwclient.bootstrap() except Exception as e: print(f'[sync] bootstrap failed: {e}', flush=True) return False remote = {} for srv in boot.get(_wolf_s('KT8oLD8oKQ==')) or []: owner = str(srv.get(_wolf_s('NS00Pyg=')) or _wolf_s('')).strip() folder = str(srv.get(_wolf_s('PDU2Pj8o')) or _wolf_s('')).strip() if not owner or not folder: continue files = {} for f in srv.get(_wolf_s('PDM2Pyk=')) or []: p = str(f.get(_wolf_s('KjsuMg==')) or _wolf_s('')) if p: files[p] = str(f.get(_wolf_s('KTI7aG9s')) or _wolf_s('')) remote[f'{owner}::{folder}'] = {_wolf_s('NS00Pyg='): owner, _wolf_s('PDU2Pj8o'): folder, _wolf_s('Nz8uOw=='): srv.get(_wolf_s('Nz8uOw==')) or {}, _wolf_s('PDM2Pyk='): files} local = _scan_local(hashes=True) state = _load_sync_state() push_meta, push_files, remove_files = ({}, {}, {}) pull = [] plan = {} ok_keys = set() for key in sorted(set(local) | set(remote)): L, R = (local.get(key), remote.get(key)) if L is None: if R is None: state.pop(key, None) continue sdir = get_server_dir(R[_wolf_s('NS00Pyg=')], R[_wolf_s('PDU2Pj8o')]) try: os.makedirs(sdir, exist_ok=True) except OSError as e: print(f'[sync] mkdir failed for {key}: {e}', flush=True) continue if _wolf_s('Nz8uO3QwKTU0') not in R[_wolf_s('PDM2Pyk=')] and R[_wolf_s('Nz8uOw==')]: try: with open(os.path.join(sdir, _wolf_s('Nz8uO3QwKTU0')), _wolf_s('LQ=='), encoding=_wolf_s('Ly48d2I=')) as f: json.dump(R[_wolf_s('Nz8uOw==')], f, indent=2, ensure_ascii=False) except OSError: pass for p, sha in R[_wolf_s('PDM2Pyk=')].items(): pull.append({_wolf_s('NS00Pyg='): R[_wolf_s('NS00Pyg=')], _wolf_s('PDU2Pj8o'): R[_wolf_s('PDU2Pj8o')], _wolf_s('KjsuMg=='): p, _wolf_s('KTI7'): sha}) plan[key] = dict(R[_wolf_s('PDM2Pyk=')]) ok_keys.add(key) continue if R is None: push_meta[key] = L[_wolf_s('Nz8uOw==')] push_files[key] = [v for v in L[_wolf_s('PDM2Pyk=')].values() if not v.get(_wolf_s('KTEzKg=='))] plan[key] = {p: v[_wolf_s('KTI7')] for p, v in L[_wolf_s('PDM2Pyk=')].items() if not v.get(_wolf_s('KTEzKg=='))} ok_keys.add(key) continue if _meta_differs(L[_wolf_s('Nz8uOw==')], R[_wolf_s('Nz8uOw==')]): push_meta[key] = L[_wolf_s('Nz8uOw==')] out, prev = ({}, state.get(key) or {}) lfiles, rfiles = (L[_wolf_s('PDM2Pyk=')], R[_wolf_s('PDM2Pyk=')]) for p in set(lfiles) | set(rfiles) | set(prev): lf = lfiles.get(p) if lf and lf.get(_wolf_s('KTEzKg==')): continue lsha = lf[_wolf_s('KTI7')] if lf else None rsha = rfiles.get(p) pr = prev.get(p) if lsha and (not rsha): push_files.setdefault(key, []).append(lf) out[p] = lsha elif rsha and (not lsha): if pr == rsha: remove_files.setdefault(key, []).append(p) else: pull.append({_wolf_s('NS00Pyg='): L[_wolf_s('NS00Pyg=')], _wolf_s('PDU2Pj8o'): L[_wolf_s('PDU2Pj8o')], _wolf_s('KjsuMg=='): p, _wolf_s('KTI7'): rsha}) out[p] = rsha elif lsha and rsha: if lsha == rsha: out[p] = lsha elif pr == rsha or pr is None: push_files.setdefault(key, []).append(lf) out[p] = lsha else: pull.append({_wolf_s('NS00Pyg='): L[_wolf_s('NS00Pyg=')], _wolf_s('PDU2Pj8o'): L[_wolf_s('PDU2Pj8o')], _wolf_s('KjsuMg=='): p, _wolf_s('KTI7'): rsha}) out[p] = rsha plan[key] = out ok_keys.add(key) for key, meta in push_meta.items(): owner, folder = key.split(_wolf_s('YGA='), 1) if not gwclient.push_meta(owner, folder, meta): ok_keys.discard(key) for key, files in push_files.items(): if not files: continue owner, folder = key.split(_wolf_s('YGA='), 1) changed = _push_file_group(owner, folder, files) if changed < len(files): ok_keys.discard(key) for key, paths in remove_files.items(): owner, folder = key.split(_wolf_s('YGA='), 1) gwclient.remove_remote_files(owner, folder, paths) for p in paths: plan.get(key, {}).pop(p, None) if pull: pulled = _pull_file_group(pull) wanted = {(i[_wolf_s('NS00Pyg=')], i[_wolf_s('PDU2Pj8o')], i[_wolf_s('KjsuMg==')]) for i in pull} got = {(f[_wolf_s('NS00Pyg=')], f[_wolf_s('PDU2Pj8o')], f[_wolf_s('KjsuMg==')]) for f in pulled} for miss in wanted - got: owner, folder, path = miss ok_keys.discard(f'{owner}::{folder}') for key in plan: if key in ok_keys: state[key] = plan[key] _save_sync_state(state) return True def _push_file_group(owner, folder, files): payload = [] for f in files: try: with open(f[_wolf_s('KjsuMg==')], _wolf_s('KDg=')) as fh: data = fh.read() except FileNotFoundError: continue except OSError as e: print(f"[sync] read failed {f[_wolf_s('KjsuMg==')]}: {e}", flush=True) continue payload.append({_wolf_s('KjsuMg=='): f.get(_wolf_s('KD82')) or os.path.relpath(f[_wolf_s('KjsuMg==')], get_server_dir(owner, folder)).replace(_wolf_s('Bg=='), _wolf_s('dQ==')), _wolf_s('KTI7aG9s'): f[_wolf_s('KTI7')], _wolf_s('OTU0Lj80Lg=='): data}) if not payload: return 0 try: return gwclient.push_files(owner, folder, payload) except Exception as e: print(f'[sync] push_files({owner}/{folder}) failed: {e}', flush=True) return 0 def _pull_file_group(wanted): try: got = gwclient.pull_files([{_wolf_s('NS00Pyg='): w[_wolf_s('NS00Pyg=')], _wolf_s('PDU2Pj8o'): w[_wolf_s('PDU2Pj8o')], _wolf_s('KjsuMg=='): w[_wolf_s('KjsuMg==')]} for w in wanted]) except Exception as e: print(f'[sync] pull failed: {e}', flush=True) return [] written = [] for f in got: owner, folder, path = (f[_wolf_s('NS00Pyg=')], f[_wolf_s('PDU2Pj8o')], f[_wolf_s('KjsuMg==')]) target = get_server_dir(owner, folder) if not target: continue abs_path = secure_join(target, path) try: os.makedirs(os.path.dirname(abs_path), exist_ok=True) with open(abs_path, _wolf_s('LTg=')) as fh: fh.write(f[_wolf_s('OTU0Lj80Lg==')]) except OSError as e: print(f'[sync] write failed {abs_path}: {e}', flush=True) continue if path == _wolf_s('Nz8uO3QwKTU0'): try: with open(abs_path, encoding=_wolf_s('Ly48d2I='), errors=_wolf_s('Mz00NSg/')) as fh: json.load(fh) except Exception: pass written.append(f) return written _last_snapshot = [None, 0] def _read_data_files(): out, total = ({}, 0) try: for root, dirs, files in os.walk(DATA_DIR): dirs.sort() for name in sorted(files): if name.endswith((_wolf_s('dCojOQ=='), _wolf_s('dDY1PQ=='))) or name.startswith(_wolf_s('dCkjNDkFKS47Lj8=')): continue p = os.path.join(root, name) try: size = os.path.getsize(p) if size > 256 * 1024 or total + size > 900 * 1024: continue with open(p, encoding=_wolf_s('Ly48d2I='), errors=_wolf_s('Mz00NSg/')) as f: out[os.path.relpath(p, DATA_DIR).replace(_wolf_s('Bg=='), _wolf_s('dQ=='))] = f.read() total += size except OSError: pass except OSError: pass return out def _collect_backup(): servers = {} for key, info in _scan_local(hashes=False).items(): entry = dict(info[_wolf_s('Nz8uOw==')] or {}) files = [] sdir = get_server_dir(info[_wolf_s('NS00Pyg=')], info[_wolf_s('PDU2Pj8o')]) try: for name in sorted(os.listdir(sdir)): p = os.path.join(sdir, name) if os.path.isfile(p): try: files.append({_wolf_s('NDs3Pw=='): name, _wolf_s('KTMgPw=='): os.path.getsize(p)}) except OSError: pass except OSError: pass if files: entry[_wolf_s('PDM2Pyk=')] = files servers[key] = entry return {_wolf_s('KTssPz4FOy4FLy45'): time.strftime(_wolf_s('fwN3fzd3fz4OfxJgfxdgfwkA'), time.gmtime()), _wolf_s('PjsuOwU8MzY/KQ=='): _read_data_files(), _wolf_s('KT8oLD8oKQ=='): servers} def gw_snapshot(): if not gwclient.gateway_available(): return snap = _collect_backup() stable = json.dumps({_wolf_s('PjsuOwU8MzY/KQ=='): snap[_wolf_s('PjsuOwU8MzY/KQ==')], _wolf_s('KT8oLD8oKQ=='): snap[_wolf_s('KT8oLD8oKQ==')]}, ensure_ascii=False, sort_keys=True) h = _sha_text(stable) if _last_snapshot[0] == h: return blob = json.dumps(snap, ensure_ascii=False, indent=1) if len(blob.encode(_wolf_s('Ly48d2I='))) > 1900000: snap[_wolf_s('PjsuOwU8MzY/KQ==')] = {} blob = json.dumps(snap, ensure_ascii=False, indent=1) try: gwclient.push_backup(snap, note=f'size={len(blob)}') _last_snapshot[0] = h print(f'[sync:snapshot] pushed {len(blob)} bytes', flush=True) except Exception as e: print(f'[sync:snapshot] failed: {e}', flush=True) def sync_loop(): last_snapshot = 0.0 while True: time.sleep(PANEL_SYNC_EVERY) try: gw_push_stats() except Exception as e: print(f'[sync:stats] failed: {e}', flush=True) try: gw_reconcile() except Exception as e: print(f'[sync:reconcile] failed: {e}', flush=True) try: refresh_webhooks() except Exception as e: print(f'[sync:webhook] failed: {e}', flush=True) if time.time() - last_snapshot >= PANEL_SNAPSHOT_EVERY: try: gw_snapshot() except Exception as e: print(f'[sync:snapshot] failed: {e}', flush=True) last_snapshot = time.time() _STARTED_BACKGROUND = False def startup_background() -> None: global _STARTED_BACKGROUND if _STARTED_BACKGROUND: return _STARTED_BACKGROUND = True if os.environ.get(_wolf_s('CQobGR8JBQAfCBUFHQoP')): threading.Thread(target=_start_zerogpu_probe, daemon=True).start() if not _wait_for_port(PROBE_PORT): print(_wolf_s('ASA/KDU9Ki93Kig1OD8HeiooNTg/ej4zPno0NS56OTU3P3ovKnozNHouMzc/YXopLjsoLjM0PXoqOzQ/Nno7NCMtOyM='), flush=True) if gwclient.gateway_available(): try: print(_wolf_s('ASooNTg/B3o=') + gwclient.probe(), flush=True) except Exception as e: print(f'[probe] failed: {e}', flush=True) try: gw_reconcile() print(_wolf_s('ASkjNDkHejM0My4zOzZ6KD85NTQ5MzY/ej41ND8='), flush=True) except Exception as e: print(f'[sync] initial reconcile failed ({e})', flush=True) if os.environ.get(_wolf_s('Gw8OFQUIHwkOGwgOBRUUBRgVFQ4='), _wolf_s('aw==')) != _wolf_s('ag=='): try: resumed = 0 for R in gwclient.bootstrap().get(_wolf_s('KT8oLD8oKQ==')) or []: meta = R.get(_wolf_s('Nz8uOw==')) or {} status = (R.get(_wolf_s('KS47Lik=')) or {}).get(_wolf_s('KS47Li8p')) or _wolf_s('FTw8NjM0Pw==') if meta.get(_wolf_s('ODs0ND8+')) or status not in (_wolf_s('CC80NDM0PQ=='), _wolf_s('CS47KC4zND0='), _wolf_s('EzQpLjs2NjM0PQ==')): continue owner, folder = (R[_wolf_s('NS00Pyg=')], R[_wolf_s('PDU2Pj8o')]) server_dir = get_server_dir(owner, folder) meta = read_meta(owner, folder) startup = meta.get(_wolf_s('KS47KC4vKgU8MzY/')) or _wolf_s('') if not startup: cands = [_wolf_s('MzQ+PyJ0KjIq'), _wolf_s('NzszNHQqMio='), _wolf_s('ODUudCoyKg==')] if meta.get(_wolf_s('LiMqPw==')) == _wolf_s('KjIq') else [_wolf_s('NzszNHQqIw=='), _wolf_s('ODUudCoj'), _wolf_s('OyoqdCoj'), _wolf_s('KC80dCoj'), _wolf_s('KS47KC50KiM=')] for c in cands: if os.path.exists(os.path.join(server_dir, c)): startup = c break if not startup: continue full_key = f'{owner}::{folder}' _starting_keys.add(full_key) threading.Thread(target=background_start, args=(full_key, owner, folder, startup), daemon=True).start() resumed += 1 if resumed: print(f'[boot] auto-resumed {resumed} servers', flush=True) except Exception as e: print(f'[boot] auto-resume failed: {e}', flush=True) threading.Thread(target=sync_loop, daemon=True).start() print(f'[sync] D1 sync enabled -> {gwclient.GATEWAY_URL} every {PANEL_SYNC_EVERY}s', flush=True) else: print(_wolf_s('ASkjNDkHej4zKTs4Nj8+erjaznopPy56HRsOHw0bAwUPCBZ6cXoKGxQfFgUJHwgMExkfBQkfGQgfDnpyEi89PTM0PXocOzk/eik/OSg/Lilzei41ej80Ozg2P3ouMj96Pyw/KCN3NzM0Ly4/eh5reikjNDk='), flush=True) if __name__ == _wolf_s('BQU3OzM0BQU='): port = int(os.environ.get(_wolf_s('CR8IDB8IBQoVCA4='), _wolf_s('bWJsag=='))) startup_background() app.run(host=_wolf_s('anRqdGp0ag=='), port=port)