Hugging Face's logo

Spaces:
mohammed978
/
wolf-host
Paused

App Files Community
wolf-host / app.py
mohammed978's picture
mohammed978
Wolf Host panel (gateway architecture, obfuscated sources)
73c1400 verified
Raw History Blame Contribute Delete
110 kB
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)