grendervill
33bdcdce68
- bot.py: Telegram-бот (/users, /create, /delete, /warp, /stats, /dashboard)
- install-bot.sh: установщик бота (systemd, конфиг /etc/mita/bot.json)
- app.py: API /api/bot/{status,install,uninstall,config}, /api/stats (CPU/RAM/диск)
- templates: раздел «Telegram бот» в UI, мониторинг CPU/RAM/диск на дашборде (2s auto-refresh)
- mita-ctl.sh: пункт 11 «Telegram-бот», удаление бота в полном uninstall
- install.sh: опциональная установка бота с инструкцией
- README.md: описание проекта и дорожная карта
404 lines
16 KiB
Python
404 lines
16 KiB
Python
#!/usr/bin/env python3
|
||
"""
|
||
mita Telegram Bot — управление сервером через Telegram
|
||
"""
|
||
import os, json, re, subprocess, psutil, logging
|
||
from datetime import datetime
|
||
from pathlib import Path
|
||
|
||
logging.basicConfig(level=logging.INFO,
|
||
format="%(asctime)s %(levelname)s [bot] %(message)s")
|
||
_log = logging.getLogger("mita_bot")
|
||
|
||
BOT_CONFIG = os.environ.get("BOT_CONFIG", "/etc/mita/bot.json")
|
||
MITA_CONFIG = "/etc/mita/server_config.json"
|
||
PANEL_CONFIG = "/etc/mita/panel.json"
|
||
|
||
try:
|
||
from telegram import Update
|
||
from telegram.ext import Application, CommandHandler, ContextTypes
|
||
except ImportError:
|
||
_log.error("python-telegram-bot не установлен. pip install python-telegram-bot")
|
||
raise SystemExit(1)
|
||
|
||
# ── config ────────────────────────────────────────────────────────────────────
|
||
def load_bot_config():
|
||
try:
|
||
return json.loads(Path(BOT_CONFIG).read_text())
|
||
except Exception:
|
||
return {}
|
||
|
||
def load_mita_config():
|
||
try:
|
||
return json.loads(Path(MITA_CONFIG).read_text())
|
||
except Exception:
|
||
return {}
|
||
|
||
def load_panel_config():
|
||
try:
|
||
return json.loads(Path(PANEL_CONFIG).read_text())
|
||
except Exception:
|
||
return {}
|
||
|
||
# ── helpers ───────────────────────────────────────────────────────────────────
|
||
def mita_cmd(*args):
|
||
r = subprocess.run(["mita", *args], capture_output=True, text=True)
|
||
return r.stdout.strip()
|
||
|
||
def _parse_traffic(s: str) -> float:
|
||
s = s.strip()
|
||
mul = {"TiB":1024**4,"GiB":1024**3,"MiB":1024**2,"KiB":1024,"B":1}
|
||
for suffix, factor in mul.items():
|
||
if s.endswith(suffix):
|
||
try:
|
||
return float(s[:-len(suffix)]) * factor
|
||
except ValueError:
|
||
return 0.0
|
||
try:
|
||
return float(s)
|
||
except ValueError:
|
||
return 0.0
|
||
|
||
def fmt_bytes(b):
|
||
if b >= 1024**4: return f"{b/1024**4:.2f} TiB"
|
||
if b >= 1024**3: return f"{b/1024**3:.2f} GiB"
|
||
if b >= 1024**2: return f"{b/1024**2:.1f} MiB"
|
||
if b >= 1024: return f"{b/1024:.0f} KiB"
|
||
return f"{b:.0f} B"
|
||
|
||
def get_server_ip():
|
||
try:
|
||
return subprocess.run(
|
||
["curl","-s","--max-time","5","ifconfig.me"],
|
||
capture_output=True, text=True).stdout.strip() or "?"
|
||
except Exception:
|
||
return "?"
|
||
|
||
def _mita_running():
|
||
try:
|
||
r = subprocess.run(["systemctl","is-active","mita"],
|
||
capture_output=True, text=True, timeout=3)
|
||
return r.stdout.strip() == "active"
|
||
except Exception:
|
||
return False
|
||
|
||
# ── auth ──────────────────────────────────────────────────────────────────────
|
||
def admin_only(func):
|
||
async def wrapper(update: Update, context: ContextTypes.DEFAULT_TYPE):
|
||
user_id = str(update.effective_user.id)
|
||
cfg = load_bot_config()
|
||
admins = cfg.get("admin_ids", [])
|
||
if user_id not in admins:
|
||
await update.message.reply_text("⛔ Доступ запрещён.")
|
||
return
|
||
return await func(update, context)
|
||
return wrapper
|
||
|
||
# ── commands ──────────────────────────────────────────────────────────────────
|
||
@admin_only
|
||
async def cmd_start(update: Update, context: ContextTypes.DEFAULT_TYPE):
|
||
await update.message.reply_text(
|
||
"🤖 *mita Bot* готов к работе\\.\n\n"
|
||
"/users \\- список пользователей\n"
|
||
"/create \\[имя\\] \\- создать пользователя\n"
|
||
"/delete \\<имя\\> \\- удалить пользователя\n"
|
||
"/warp \\<имя\\> on\\|off \\- управление WARP\n"
|
||
"/stats \\- статистика сервера\n"
|
||
"/dashboard \\- полный дашборд\n"
|
||
"/help \\- все команды",
|
||
parse_mode="MarkdownV2"
|
||
)
|
||
|
||
@admin_only
|
||
async def cmd_help(update: Update, context: ContextTypes.DEFAULT_TYPE):
|
||
await update.message.reply_text(
|
||
"📋 *Команды*\n\n"
|
||
"/users \\- список пользователей с трафиком и статусом\n"
|
||
"/create \\- создать пользователя \\(случайное имя\\)\n"
|
||
"/create `имя` \\- создать с указанным именем\n"
|
||
"/delete `имя` \\- удалить пользователя\n"
|
||
"/warp `имя` on \\- включить WARP\n"
|
||
"/warp `имя` off \\- выключить WARP\n"
|
||
"/stats \\- CPU, RAM, диск\n"
|
||
"/dashboard \\- полный обзор сервера\n"
|
||
"/config `имя` \\- клиентский конфиг",
|
||
parse_mode="MarkdownV2"
|
||
)
|
||
|
||
@admin_only
|
||
async def cmd_users(update: Update, context: ContextTypes.DEFAULT_TYPE):
|
||
cfg = load_mita_config()
|
||
users = cfg.get("users", [])
|
||
if not users:
|
||
await update.message.reply_text("👤 Нет пользователей.")
|
||
return
|
||
|
||
raw = mita_cmd("get", "users")
|
||
pc = load_panel_config()
|
||
warp_users = set(pc.get("warp_users", []))
|
||
|
||
lines = []
|
||
today = datetime.now().date()
|
||
|
||
data_lines = []
|
||
for line in raw.splitlines():
|
||
line = line.strip()
|
||
if not line or line.upper().startswith("USER"):
|
||
continue
|
||
data_lines.append(line)
|
||
|
||
stats_map = {}
|
||
for line in data_lines:
|
||
parts = re.split(r"\s{2,}", line.strip())
|
||
if len(parts) < 3:
|
||
parts = line.split()
|
||
if len(parts) < 3:
|
||
continue
|
||
try:
|
||
name = parts[0]
|
||
traffic_parts = [p for p in parts[1:] if any(u in p for u in ["TiB","GiB","MiB","KiB","iB","B"])]
|
||
d1 = d30 = 0.0
|
||
if len(traffic_parts) >= 6:
|
||
d1 = _parse_traffic(traffic_parts[0]) + _parse_traffic(traffic_parts[1])
|
||
d30= _parse_traffic(traffic_parts[4]) + _parse_traffic(traffic_parts[5])
|
||
elif len(traffic_parts) >= 4:
|
||
d1 = _parse_traffic(traffic_parts[0]) + _parse_traffic(traffic_parts[1])
|
||
d30= _parse_traffic(traffic_parts[2]) + _parse_traffic(traffic_parts[3])
|
||
elif len(traffic_parts) >= 2:
|
||
d30= _parse_traffic(traffic_parts[0]) + _parse_traffic(traffic_parts[1])
|
||
|
||
online = False
|
||
la_raw = parts[1].strip() if len(parts) > 1 else ""
|
||
if la_raw and la_raw.lower() not in ("never","-","n/a","никогда"):
|
||
try:
|
||
la_date = datetime.strptime(la_raw[:10], "%Y-%m-%d").date()
|
||
if (today - la_date).days == 0:
|
||
online = True
|
||
except Exception:
|
||
pass
|
||
|
||
stats_map[name] = {"online": online, "day_mb": round(d1/1024/1024, 2),
|
||
"month_mb": round(d30/1024/1024, 2)}
|
||
except Exception:
|
||
continue
|
||
|
||
for u in users:
|
||
name = u["name"]
|
||
s = stats_map.get(name, {})
|
||
w = "🟢" if name in warp_users else "⚪"
|
||
o = "🟢" if s.get("online") else "🔴"
|
||
day = f"{s.get('day_mb', 0):.1f} МБ" if s.get("day_mb") else "—"
|
||
mon = f"{s.get('month_mb', 0):.1f} МБ" if s.get("month_mb") else "—"
|
||
lines.append(f"{o} `{name}` {w} \\| день: {day} \\| мес: {mon}")
|
||
|
||
await update.message.reply_text(
|
||
"👥 *Пользователи*\n\n" + "\n".join(lines),
|
||
parse_mode="MarkdownV2"
|
||
)
|
||
|
||
@admin_only
|
||
async def cmd_create(update: Update, context: ContextTypes.DEFAULT_TYPE):
|
||
args = context.args
|
||
cfg = load_mita_config()
|
||
existing = {u["name"] for u in cfg.get("users", [])}
|
||
|
||
if args:
|
||
name = args[0].strip()
|
||
else:
|
||
import secrets
|
||
adj = ["swift","brave","quiet","cool","sharp","calm","bright","dark","wild","free"]
|
||
nouns = ["fox","hawk","river","storm","ember","peak","orbit","tide","frost","spark"]
|
||
name = f"{secrets.choice(adj)}_{secrets.choice(nouns)}_{secrets.randbelow(9000)+1000}"
|
||
while name in existing:
|
||
name = f"{secrets.choice(adj)}_{secrets.choice(nouns)}_{secrets.randbelow(9000)+1000}"
|
||
|
||
if name in existing:
|
||
await update.message.reply_text(f"❌ Пользователь `{name}` уже существует\\.")
|
||
return
|
||
|
||
import string
|
||
chars = string.ascii_letters + string.digits + "!@#%^*_-=+?."
|
||
password = "".join(secrets.choice(chars) for _ in range(64))
|
||
|
||
cfg.setdefault("users", []).append({"name": name, "password": password})
|
||
Path(MITA_CONFIG).write_text(json.dumps(cfg, indent=2, ensure_ascii=False))
|
||
|
||
subprocess.run(["mita", "apply", "config", MITA_CONFIG], capture_output=True)
|
||
subprocess.run(["systemctl", "restart", "mita"], capture_output=True)
|
||
|
||
ip = get_server_ip()
|
||
bindings = cfg.get("portBindings", [{}])[0]
|
||
port = bindings.get("portRange", str(bindings.get("port","?")))
|
||
|
||
await update.message.reply_text(
|
||
f"✅ Пользователь *{name}* создан\\.\n\n"
|
||
f"Сервер: `{ip}`\n"
|
||
f"Порт: `{port}`\n"
|
||
f"Пароль: `{password}`\n\n"
|
||
f"Получить JSON\\-конфиг: /config `{name}`",
|
||
parse_mode="MarkdownV2"
|
||
)
|
||
|
||
@admin_only
|
||
async def cmd_delete(update: Update, context: ContextTypes.DEFAULT_TYPE):
|
||
if not context.args:
|
||
await update.message.reply_text("❌ Укажите имя: `/delete имя`", parse_mode="MarkdownV2")
|
||
return
|
||
name = context.args[0].strip()
|
||
cfg = load_mita_config()
|
||
cfg["users"] = [u for u in cfg.get("users", []) if u["name"] != name]
|
||
Path(MITA_CONFIG).write_text(json.dumps(cfg, indent=2, ensure_ascii=False))
|
||
subprocess.run(["mita", "apply", "config", MITA_CONFIG], capture_output=True)
|
||
subprocess.run(["systemctl", "restart", "mita"], capture_output=True)
|
||
await update.message.reply_text(f"🗑 Пользователь `{name}` удалён\\.", parse_mode="MarkdownV2")
|
||
|
||
@admin_only
|
||
async def cmd_warp(update: Update, context: ContextTypes.DEFAULT_TYPE):
|
||
if len(context.args) < 2:
|
||
await update.message.reply_text(
|
||
"❌ Формат: `/warp имя on` или `/warp имя off`", parse_mode="MarkdownV2")
|
||
return
|
||
name = context.args[0].strip()
|
||
action = context.args[1].lower()
|
||
if action not in ("on", "off"):
|
||
await update.message.reply_text("❌ Укажите `on` или `off`\\.", parse_mode="MarkdownV2")
|
||
return
|
||
|
||
pc = load_panel_config()
|
||
warp_users = set(pc.get("warp_users", []))
|
||
if action == "on":
|
||
warp_users.add(name)
|
||
else:
|
||
warp_users.discard(name)
|
||
pc["warp_users"] = list(warp_users)
|
||
Path(PANEL_CONFIG).write_text(json.dumps(pc, indent=2))
|
||
await update.message.reply_text(
|
||
f"🔄 WARP для `{name}`: *{action.upper()}* \\(сохранено в panel\\.json\\)",
|
||
parse_mode="MarkdownV2"
|
||
)
|
||
|
||
@admin_only
|
||
async def cmd_config(update: Update, context: ContextTypes.DEFAULT_TYPE):
|
||
if not context.args:
|
||
await update.message.reply_text("❌ Укажите имя: `/config имя`", parse_mode="MarkdownV2")
|
||
return
|
||
name = context.args[0].strip()
|
||
cfg = load_mita_config()
|
||
user = next((u for u in cfg.get("users", []) if u["name"] == name), None)
|
||
if not user:
|
||
await update.message.reply_text(f"❌ Пользователь `{name}` не найден\\.", parse_mode="MarkdownV2")
|
||
return
|
||
ip = get_server_ip()
|
||
bindings = cfg.get("portBindings", [{}])[0]
|
||
port = bindings.get("portRange", str(bindings.get("port","?")))
|
||
data = json.dumps({
|
||
"profiles": [{"profileName": "default",
|
||
"user": {"name": user["name"], "password": user["password"]},
|
||
"servers": [{"ipAddress": ip,
|
||
"portBindings": [{"portRange": port,
|
||
"protocol": bindings.get("protocol","TCP")}]}]}],
|
||
"activeProfile": "default",
|
||
"rpcPort": 8964,
|
||
"socks5Port": 1080,
|
||
}, indent=2, ensure_ascii=False)
|
||
|
||
await update.message.reply_text(f"```json\n{data}\n```", parse_mode=None)
|
||
|
||
@admin_only
|
||
async def cmd_stats(update: Update, context: ContextTypes.DEFAULT_TYPE):
|
||
cpu = psutil.cpu_percent(interval=1)
|
||
mem = psutil.virtual_memory()
|
||
disk = psutil.disk_usage("/")
|
||
boot = datetime.fromtimestamp(psutil.boot_time()).strftime("%d.%m.%Y %H:%M")
|
||
|
||
await update.message.reply_text(
|
||
f"📊 *Сервер*\n\n"
|
||
f"CPU: `{cpu:.1f}%`\n"
|
||
f"RAM: `{mem.percent:.1f}%` \\({fmt_bytes(mem.used)} / {fmt_bytes(mem.total)}\\)\n"
|
||
f"Диск: `{disk.percent:.1f}%` \\({fmt_bytes(disk.used)} / {fmt_bytes(disk.total)}\\)\n"
|
||
f"Аптайм: с `{boot}`\n"
|
||
f"mita: {'🟢 работает' if _mita_running() else '🔴 остановлен'}",
|
||
parse_mode="MarkdownV2"
|
||
)
|
||
|
||
@admin_only
|
||
async def cmd_dashboard(update: Update, context: ContextTypes.DEFAULT_TYPE):
|
||
cpu = psutil.cpu_percent(interval=1)
|
||
mem = psutil.virtual_memory()
|
||
disk = psutil.disk_usage("/")
|
||
ip = get_server_ip()
|
||
mita_ok = _mita_running()
|
||
|
||
warp_ip = "недоступен"
|
||
try:
|
||
r = subprocess.run(["curl","-s","--max-time","5","--proxy",
|
||
"socks5h://127.0.0.1:40000","https://ifconfig.me"],
|
||
capture_output=True, text=True)
|
||
warp_ip = r.stdout.strip()
|
||
except Exception:
|
||
pass
|
||
|
||
cfg = load_mita_config()
|
||
user_count = len(cfg.get("users", []))
|
||
bindings = cfg.get("portBindings", [{}])[0]
|
||
port = bindings.get("portRange", str(bindings.get("port","?")))
|
||
|
||
traffic = None
|
||
try:
|
||
raw = mita_cmd("get", "users")
|
||
d_lines = [l.strip() for l in raw.splitlines() if l.strip() and not l.upper().startswith("USER")]
|
||
week_total = month_total = 0.0
|
||
for line in d_lines:
|
||
parts = re.split(r"\s{2,}", line.strip())
|
||
if len(parts) < 3:
|
||
parts = line.split()
|
||
if len(parts) < 3:
|
||
continue
|
||
tp = [p for p in parts[1:] if any(u in p for u in ["TiB","GiB","MiB","KiB","iB","B"])]
|
||
if len(tp) >= 6:
|
||
week_total += _parse_traffic(tp[2]) + _parse_traffic(tp[3])
|
||
month_total += _parse_traffic(tp[4]) + _parse_traffic(tp[5])
|
||
traffic = (round(week_total/1024**3, 2), round(month_total/1024**3, 2))
|
||
except Exception:
|
||
pass
|
||
|
||
w, m = traffic or (0, 0)
|
||
|
||
await update.message.reply_text(
|
||
f"📊 *Дашборд*\n\n"
|
||
f"IP сервера: `{ip}`\n"
|
||
f"IP WARP: `{warp_ip}`\n"
|
||
f"Порт mita: `{port}`\n"
|
||
f"Пользователей: `{user_count}`\n"
|
||
f"Трафик нед\\.: `{w} ГБ`\n"
|
||
f"Трафик мес\\.: `{m} ГБ`\n"
|
||
f"mita: {'🟢' if mita_ok else '🔴'}\n"
|
||
f"CPU: `{cpu:.1f}%` RAM: `{mem.percent:.1f}%` Диск: `{disk.percent:.1f}%`",
|
||
parse_mode="MarkdownV2"
|
||
)
|
||
|
||
# ── main ──────────────────────────────────────────────────────────────────────
|
||
def main():
|
||
cfg = load_bot_config()
|
||
token = os.environ.get("BOT_TOKEN", cfg.get("token", ""))
|
||
if not token:
|
||
_log.error("BOT_TOKEN не задан — ни в env, ни в %s", BOT_CONFIG)
|
||
raise SystemExit(1)
|
||
|
||
app = Application.builder().token(token).build()
|
||
app.add_handler(CommandHandler("start", cmd_start))
|
||
app.add_handler(CommandHandler("help", cmd_help))
|
||
app.add_handler(CommandHandler("users", cmd_users))
|
||
app.add_handler(CommandHandler("create", cmd_create))
|
||
app.add_handler(CommandHandler("delete", cmd_delete))
|
||
app.add_handler(CommandHandler("warp", cmd_warp))
|
||
app.add_handler(CommandHandler("config", cmd_config))
|
||
app.add_handler(CommandHandler("stats", cmd_stats))
|
||
app.add_handler(CommandHandler("dashboard", cmd_dashboard))
|
||
|
||
_log.info("Бот запущен")
|
||
app.run_polling()
|
||
|
||
if __name__ == "__main__":
|
||
main()
|