"""
comms-agent — единый административный бот buryan-hub.
Собран слиянием двух прежних ботов:
* бот на CT 108 — /issues и heartbeat в agent_registry;
* бот на VPS — двусторонний Matrix и /restart через Remediation API.
Работает в режиме опроса Telegram, поэтому у бота НЕ должен быть
установлен webhook: Telegram не разрешает одновременно getUpdates и webhook.
Webhook закреплён за отдельным ботом Auth (@Adm_buryans_bot) для потока
самообслуживания F6-2.
"""
import os
import asyncio
import base64
import logging
import aiohttp
import asyncpg
from aiogram import Bot, Dispatcher
from aiogram.client.session.aiohttp import AiohttpSession
from aiogram.filters import Command
from aiogram.types import (
CallbackQuery,
InlineKeyboardButton,
InlineKeyboardMarkup,
Message,
)
from nio import AsyncClient, RoomMessageText
logging.basicConfig(
level=logging.INFO,
format="%(asctime)s %(levelname)s %(name)s: %(message)s",
)
log = logging.getLogger("comms-agent")
dp = Dispatcher()
bot_instance: Bot | None = None
# --- Конфигурация -----------------------------------------------------------
ADMIN_ID = str(os.getenv("ADMIN_ID") or "0")
GITEA_URL = (os.getenv("GITEA_URL") or "http://192.168.1.140:3000").rstrip("/")
GITEA_REPO = os.getenv("GITEA_REPO") or "agent-qwen/buryan-infra"
GITEA_TOKEN = os.getenv("GITEA_TOKEN") or ""
PG_DSN = dict(
host=os.getenv("PG_HOST"),
database=os.getenv("PG_DB"),
user=os.getenv("PG_USER"),
password=os.getenv("PG_PASSWORD"),
port=int(os.getenv("PG_PORT") or 5432),
)
REMEDIATION_API_URL = (os.getenv("REMEDIATION_API_URL") or "").rstrip("/")
REMEDIATION_API_KEY = os.getenv("REMEDIATION_API_KEY") or ""
MATRIX_ROOM_ID = os.getenv("MATRIX_ROOM_ID") or ""
matrix_client = AsyncClient(os.getenv("MATRIX_HOMESERVER") or "https://matrix.buryans.ru")
def _load_help(bot_key: str = "adm") -> str:
"""Справка из общего справочника команд.
Команды не зашиты в код: правим commands.yaml, помощь обновляется сама.
Если справочник недоступен — прежний текст, бот продолжает работать.
"""
try:
import gen_help
return gen_help.help_text(gen_help.load(), bot_key)
except Exception as _exc: # noqa: BLE001
log.warning("справочник команд недоступен: %s", _exc)
return (
"Доступные команды:\n"
"/status — состояние хостов\n"
"/issues — открытые задачи Gitea\n"
"/runbook <сервис> — ранбук сервиса\n"
"/restart <сервис> — перезапуск через Remediation API"
)
HELP_TEXT = _load_help("adm")
gitea_headers = {"Authorization": f"token {GITEA_TOKEN}"}
def is_admin(obj) -> bool:
user = getattr(obj, "from_user", None)
if user is None and getattr(obj, "message", None) is not None:
user = obj.message.from_user
return user is not None and str(user.id) == ADMIN_ID
# --- Matrix -----------------------------------------------------------------
async def send_matrix_message(text: str) -> None:
if not MATRIX_ROOM_ID or not matrix_client.access_token:
return
html_text = text.replace("\n", "
").replace("**", "").replace("`", "")
try:
await matrix_client.room_send(
room_id=MATRIX_ROOM_ID,
message_type="m.room.message",
content={
"msgtype": "m.text",
"body": text,
"format": "org.matrix.custom.html",
"formatted_body": html_text,
},
)
except Exception as exc: # noqa: BLE001 - сообщение не должно ронять бота
log.error("Matrix send error: %s", exc)
async def reply(text: str, source: str, message: Message | None = None) -> None:
"""Отправляет ответ туда, откуда пришла команда, и дублирует в Matrix."""
if source == "telegram" and message is not None:
await message.answer(text)
else:
await send_matrix_message(text)
# --- Логика команд ----------------------------------------------------------
async def handle_status_logic(source: str, message: Message | None = None) -> None:
try:
conn = await asyncpg.connect(**PG_DSN)
rows = await conn.fetch(
"SELECT host, ip, mem, disk FROM host_states ORDER BY host ASC LIMIT 10;"
)
await conn.close()
if not rows:
text = "Данных о хостах пока нет."
else:
lines = [
f"{r['host']} ({r['ip']}): RAM {r['mem'] or '?'}%, диск {r['disk'] or '?'}%"
for r in rows
]
text = "Хосты:\n" + "\n".join(lines)
except Exception as exc: # noqa: BLE001
text = f"Ошибка базы: {exc}"
await reply(text, source, message)
async def handle_issues_logic(source: str, message: Message | None = None) -> None:
url = f"{GITEA_URL}/api/v1/repos/{GITEA_REPO}/issues?state=open&limit=10"
try:
async with aiohttp.ClientSession() as session:
async with session.get(url, headers=gitea_headers) as resp:
if resp.status != 200:
text = f"Gitea вернул {resp.status}"
else:
issues = await resp.json()
if not issues:
text = "Открытых задач нет."
else:
lines = [f"#{i['number']} {i['title']}" for i in issues]
text = f"Открытые задачи ({len(issues)}):\n" + "\n".join(lines)
except Exception as exc: # noqa: BLE001
text = f"Ошибка Gitea: {exc}"
await reply(text, source, message)
async def fetch_runbook(service: str) -> str | None:
"""Ищет ранбук сначала в services/, затем в knowledge/runbooks/."""
for path in (
f"services/{service}/runbook.md",
f"knowledge/runbooks/{service}.md",
):
url = f"{GITEA_URL}/api/v1/repos/{GITEA_REPO}/contents/{path}?ref=main"
try:
async with aiohttp.ClientSession() as session:
async with session.get(url, headers=gitea_headers) as resp:
if resp.status == 200:
data = await resp.json()
return base64.b64decode(data["content"]).decode("utf-8")
except Exception as exc: # noqa: BLE001
log.error("Gitea fetch error for %s: %s", path, exc)
return None
async def handle_runbook_logic(
service: str, source: str, message: Message | None = None
) -> None:
content = await fetch_runbook(service)
if content is None:
await reply(
f"Ранбук для «{service}» не найден ни в services/, ни в knowledge/runbooks/.",
source,
message,
)
return
# Отправляем без разметки: содержимое ранбука ломает парсер Markdown.
text = f"Ранбук: {service}\n\n{content[:3800]}"
if source == "telegram" and message is not None:
keyboard = InlineKeyboardMarkup(
inline_keyboard=[
[
InlineKeyboardButton(
text="Перезапустить", callback_data=f"restart_{service}"
)
]
]
)
await message.answer(text, reply_markup=keyboard)
else:
await send_matrix_message(text)
async def handle_restart_logic(
service: str, source: str, message: Message | None = None
) -> None:
if not REMEDIATION_API_URL:
await reply("Remediation API не настроен (REMEDIATION_API_URL пуст).", source, message)
return
await reply(f"Запрашиваю перезапуск: {service}...", source, message)
headers = {
"X-API-Key": REMEDIATION_API_KEY,
"Content-Type": "application/json",
}
try:
async with aiohttp.ClientSession() as session:
async with session.post(
f"{REMEDIATION_API_URL}/api/v1/remediate",
json={"action": "restart_service", "target": service},
headers=headers,
timeout=aiohttp.ClientTimeout(total=120),
) as resp:
data = await resp.json()
if resp.status == 200:
text = f"Готово: {data.get('message', 'ok')}"
else:
text = f"Отказ: {data.get('detail', resp.status)}"
except Exception as exc: # noqa: BLE001
text = f"Ошибка связи с Remediation API: {exc}"
await reply(text, source, message)
async def handle_runbook_and_restart(service: str, source: str, message: Message | None = None) -> None:
await handle_runbook_logic(service, source, message)
# --- Telegram ---------------------------------------------------------------
@dp.message(Command("start", "help"))
async def cmd_start(message: Message) -> None:
if is_admin(message):
await message.answer("comms-agent на связи.\n\n" + HELP_TEXT)
else:
await message.answer(f"Доступ запрещён. Ваш ID: {message.from_user.id}")
@dp.message(Command("status"))
async def cmd_status(message: Message) -> None:
if is_admin(message):
await handle_status_logic("telegram", message)
@dp.message(Command("issues"))
async def cmd_issues(message: Message) -> None:
if is_admin(message):
await handle_issues_logic("telegram", message)
@dp.message(Command("runbook"))
async def cmd_runbook(message: Message) -> None:
if not is_admin(message):
return
parts = message.text.split(maxsplit=1)
if len(parts) < 2:
await message.answer("Использование: /runbook <сервис>")
return
await handle_runbook_logic(parts[1].strip().lower(), "telegram", message)
@dp.message(Command("restart"))
async def cmd_restart(message: Message) -> None:
if not is_admin(message):
return
parts = message.text.split(maxsplit=1)
if len(parts) < 2:
await message.answer("Использование: /restart <сервис>")
return
await handle_restart_logic(parts[1].strip().lower(), "telegram", message)
@dp.callback_query(lambda c: (c.data or "").startswith("restart_"))
async def on_restart_callback(callback: CallbackQuery) -> None:
if not is_admin(callback):
await callback.answer("Доступ запрещён", show_alert=True)
return
service = callback.data.split("_", 1)[1]
await callback.message.edit_text(f"Запрашиваю перезапуск: {service}...")
await handle_restart_logic(service, "telegram")
await callback.answer()
# --- Одобрение обновлений (задача F6-4) -------------------------------------
UPDATE_ACTIONS = {
"update_now": ("now", "approved", "✅ Обновление одобрено, запустится в течение минуты"),
"update_defer": ("defer", "deferred", "⏰ Отложено до 03:00"),
"update_ignore": ("ignore", "cancelled", "❌ Обновление отклонено"),
}
async def decide_update(service: str, action: str, status: str, who: str) -> int | None:
"""Ставит решение по обновлению в очередь update_queue.
Если по этому сервису уже есть незакрытая заявка — обновляем её,
а не создаём вторую. Возвращает номер заявки.
"""
conn = await asyncpg.connect(**PG_DSN)
try:
row = await conn.fetchrow(
"""
UPDATE update_queue
SET action = $1, status = $2, decided_at = now(), requested_by = $3
WHERE id = (SELECT id FROM update_queue
WHERE service = $4
AND status IN ('pending', 'deferred', 'approved')
ORDER BY id DESC LIMIT 1)
RETURNING id
""",
action, status, who, service,
)
if row:
return row["id"]
row = await conn.fetchrow(
"""
INSERT INTO update_queue (service, action, status, requested_by, decided_at)
VALUES ($1, $2, $3, $4, now())
RETURNING id
""",
service, action, status, who,
)
return row["id"] if row else None
except Exception as exc: # noqa: BLE001
log.error("Не удалось записать решение по обновлению: %s", exc)
return None
finally:
await conn.close()
@dp.callback_query(lambda c: (c.data or "").startswith("update_"))
async def on_update_callback(callback: CallbackQuery) -> None:
"""Обрабатывает кнопки «Обновить сейчас», «Отложить», «Игнорировать».
Кнопки приходят боту, потому что он опрашивает Telegram: нажатие
доступно и без вебхука. Задача попадает в update_queue, откуда её
забирает update-runner.sh.
"""
if not is_admin(callback):
await callback.answer("Доступ запрещён", show_alert=True)
return
action_key, _, service = (callback.data or "").partition(":")
if action_key not in UPDATE_ACTIONS or not service:
await callback.answer("Неизвестное действие", show_alert=True)
return
action, status, text = UPDATE_ACTIONS[action_key]
who = callback.from_user.username or str(callback.from_user.id)
qid = await decide_update(service, action, status, who)
if qid is None:
await callback.answer("Не удалось записать решение", show_alert=True)
return
log.info("решение по обновлению: сервис=%s действие=%s заявка=%s", service, action, qid)
try:
await callback.message.edit_text(f"{callback.message.text}\n\n{text}")
except Exception: # noqa: BLE001
pass
await callback.answer(text)
# --- Matrix приём команд ----------------------------------------------------
# --- Команды обновлений в Matrix -------------------------------------------
# Администраторы Matrix: только они могут менять состояние служб.
# Раньше проверки прав в Matrix не было вовсе — команду мог вызвать
# любой участник комнаты. Здесь это исправлено.
MATRIX_ADMINS = {
u.strip() for u in (os.getenv("MATRIX_ADMINS") or "@akadmin:matrix.buryans.ru").split(",")
if u.strip()
}
def is_matrix_admin(sender: str) -> bool:
"""Может ли этот пользователь Matrix менять состояние служб."""
return sender in MATRIX_ADMINS
async def show_help(source: str, arg: str = "") -> None:
"""Справка из общего справочника команд."""
try:
import gen_help
data = gen_help.load()
if arg:
text = gen_help.command_help(data, arg) or gen_help.suggest(data, arg)
else:
text = gen_help.help_text(data, "adm")
except Exception as exc: # noqa: BLE001
log.warning("справочник недоступен: %s", exc)
text = HELP_TEXT
await reply(text, source)
async def show_update_queue(source: str) -> None:
"""Очередь обновлений: номер, служба, версия, состояние."""
try:
conn = await asyncpg.connect(**PG_DSN)
try:
rows = await conn.fetch(
"SELECT id, service, current_version, new_version, status "
"FROM update_queue ORDER BY id DESC LIMIT 15"
)
waiting = await conn.fetchval(
"SELECT count(*) FROM update_queue "
"WHERE status IN ('pending','deferred','approved')"
)
finally:
await conn.close()
except Exception as exc: # noqa: BLE001
await reply(f"Не удалось прочитать очередь: {exc}", source)
return
if not rows:
await reply("Очередь обновлений пуста.", source)
return
marks = {
"pending": "ждёт решения", "approved": "одобрено", "rejected": "отклонено",
"deferred": "отложено", "done": "выполнено", "failed": "неудача",
"cancelled": "отменено",
}
lines = ["Очередь обновлений", ""]
for r in rows:
ver = (r["current_version"] or "?") + " -> " + (r["new_version"] or "?")
lines.append('No' + str(r["id"]) + ' ' + str(r["service"]) + " — " + ver)
lines.append(" " + marks.get(r["status"], r["status"] or "?"))
lines.append("")
lines.append("Ждут решения: " + str(waiting))
lines.append("Одобрить: /approve НОМЕР Отклонить: /reject НОМЕР")
await reply("\n".join(lines), source)
async def decide_by_number(arg: str, action: str, status: str, sender: str, source: str) -> None:
"""Одобрение или отклонение заявки по номеру."""
if not is_matrix_admin(sender):
await reply("Недостаточно прав для этого действия.", source)
return
arg = (arg or "").strip().lstrip("#")
if not arg.isdigit():
await reply("Укажите номер заявки, например: /" + action + " 17", source)
return
num = int(arg)
try:
conn = await asyncpg.connect(**PG_DSN)
try:
row = await conn.fetchrow(
"UPDATE update_queue SET status = $1, action = $2, decided_at = now(), "
"requested_by = $3 WHERE id = $4 "
"RETURNING id, service, new_version",
status, action, sender, num,
)
finally:
await conn.close()
except Exception as exc: # noqa: BLE001
await reply(f"Не удалось записать решение: {exc}", source)
return
if not row:
await reply(f"Заявка No{num} не найдена.", source)
return
word = "одобрена" if status == "approved" else "отклонена"
await reply(
"Заявка No" + str(row["id"]) + " (" + str(row["service"]) + " -> "
+ str(row["new_version"] or "?") + ") " + word + ".\n"
"Решение записано, исполнитель обновлений его подхватит.",
source,
)
async def matrix_message_callback(room, event) -> None:
if room.room_id != MATRIX_ROOM_ID:
return
if not isinstance(event, RoomMessageText):
return
if event.sender == matrix_client.user_id:
return
text = (event.body or "").strip()
log.info("Matrix команда от %s: %s", event.sender, text)
arg = text.split(" ", 1)[1].strip() if " " in text else ""
low = text.lower()
if low.startswith(("/help", "!help")):
await show_help("matrix", arg)
elif low.startswith(("/queue", "!queue")):
await show_update_queue("matrix")
elif low.startswith(("/approve", "!approve")):
await decide_by_number(arg, "approve", "approved", event.sender, "matrix")
elif low.startswith(("/reject", "!reject")):
await decide_by_number(arg, "reject", "rejected", event.sender, "matrix")
elif low.startswith(("/status", "!status")):
await handle_status_logic("matrix")
elif low.startswith(("/issues", "!issues")):
await handle_issues_logic("matrix")
elif low.startswith(("/runbook ", "!runbook ")):
await handle_runbook_logic(arg.lower(), "matrix")
elif low.startswith(("/restart ", "!restart ")):
if not is_matrix_admin(event.sender):
await reply("Недостаточно прав для перезапуска.", "matrix")
else:
await handle_restart_logic(arg.lower(), "matrix")
else:
try:
import gen_help
hint = gen_help.suggest(gen_help.load(), text.split(" ")[0])
except Exception: # noqa: BLE001
hint = "Неизвестная команда: " + text
await reply(hint, "matrix")
async def matrix_sync_loop() -> None:
matrix_client.access_token = os.getenv("MATRIX_ACCESS_TOKEN")
matrix_client.user_id = os.getenv(
"MATRIX_USER_ID", "@comms_agent:matrix.buryans.ru"
)
if not matrix_client.access_token:
log.warning("MATRIX_ACCESS_TOKEN не задан — Matrix-канал выключен")
return
try:
await matrix_client.sync(timeout=30000)
except Exception as exc: # noqa: BLE001
log.error("Первичная синхронизация Matrix не удалась: %s", exc)
return
matrix_client.add_event_callback(matrix_message_callback, RoomMessageText)
log.info("Matrix-слушатель запущен")
while True:
try:
await matrix_client.sync(timeout=30000)
except Exception as exc: # noqa: BLE001
log.error("Matrix sync error: %s", exc)
await asyncio.sleep(5)
# --- Реестр агентов ---------------------------------------------------------
async def heartbeat() -> None:
while True:
try:
conn = await asyncpg.connect(**PG_DSN)
await conn.execute(
"INSERT INTO agent_registry (name, domain, status, last_heartbeat) "
"VALUES ('comms-agent', 'comms', 'active', CURRENT_TIMESTAMP) "
"ON CONFLICT (name) DO UPDATE SET status='active', "
"last_heartbeat=CURRENT_TIMESTAMP"
)
await conn.close()
except Exception as exc: # noqa: BLE001
log.error("Heartbeat: %s", exc)
await asyncio.sleep(30)
# --- Запуск -----------------------------------------------------------------
async def main() -> None:
global bot_instance
log.info("Запуск comms-agent (Telegram + Matrix)...")
session = AiohttpSession(proxy=os.getenv("HTTP_PROXY") or None)
bot_instance = Bot(token=os.getenv("BOT_TOKEN"), session=session)
me = await bot_instance.get_me()
log.info("Бот @%s (id=%s), админ ID=%s", me.username, me.id, ADMIN_ID)
webhook = await bot_instance.get_webhook_info()
if webhook.url:
log.error(
"У бота установлен webhook (%s) — опрос работать не будет. "
"Нужен отдельный бот без webhook.",
webhook.url,
)
asyncio.create_task(heartbeat())
asyncio.create_task(matrix_sync_loop())
try:
await dp.start_polling(bot_instance)
finally:
await session.close()
if __name__ == "__main__":
asyncio.run(main())