Files
buryan-infra/ops/bots/hub/matrix.py
T
buryan-agent e0309080bc API данных: боты сохраняют всё в папку проекта
POST /data/<коллекция> — запись документа, GET /data/<коллекция> — чтение,
POST /export — выгрузка в /root/buryan-infra/data/.

Боты при любом пожелании пишут его в коллекцию wishes (кто, какой бот,
номер, текст). Команда !export выгружает коллекцию из чата. Каждый день
в 23:00 cron выгружает wishes, dialog, events и копирует журналы.

Проверено: пожелание от @polina легло в API и в файл, !export вернул путь,
в папке проекта 6 файлов (wishes, dialog, events, logs).
2026-10-19 20:13:37 +03:00

425 lines
17 KiB
Python
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
"""Минимальный клиент Matrix: отправка сообщений и длинный опрос."""
import json
import threading
import time
import urllib.parse
import urllib.request
class Matrix:
def __init__(self, homeserver, user_id, token):
self.hs = homeserver.rstrip("/")
self.user_id = user_id
self.token = token
self.txn = int(time.time() * 1000)
def _req(self, method, path, payload=None, timeout=40):
url = f"{self.hs}{path}"
headers = {"Authorization": f"Bearer {self.token}"}
data = None
if payload is not None:
data = json.dumps(payload).encode()
headers["Content-Type"] = "application/json"
req = urllib.request.Request(url, data=data, headers=headers, method=method)
try:
with urllib.request.urlopen(req, timeout=timeout) as r:
return json.loads(r.read() or b"{}")
except Exception as e:
return {"error": str(e)[:120]}
def send(self, room_id, text, formatted=None):
self.txn += 1
rid = urllib.parse.quote(room_id, safe="")
body = {"msgtype": "m.text", "body": text}
if formatted:
body["format"] = "org.matrix.custom.html"
body["formatted_body"] = formatted
return self._req("PUT", f"/_matrix/client/v3/rooms/{rid}/send/m.room.message/{self.txn}", body)
def send_chunked(self, room_id, text, limit=12000):
"""Matrix режет длинные сообщения — отправляем частями."""
if len(text) <= limit:
return self.send(room_id, text)
parts, buf = [], ""
for line in text.split("\n"):
if len(buf) + len(line) + 1 > limit:
parts.append(buf)
buf = line
else:
buf = f"{buf}\n{line}" if buf else line
if buf:
parts.append(buf)
for i, p in enumerate(parts):
prefix = f"({i + 1}/{len(parts)})\n" if len(parts) > 1 else ""
self.send(room_id, prefix + p)
return {"ok": True}
def set_typing(self, room_id, typing=True, timeout=15000):
rid = urllib.parse.quote(room_id, safe="")
return self._req("PUT", f"/_matrix/client/v3/rooms/{rid}/typing/{self.user_id}",
{"typing": typing, "timeout": timeout}, timeout=8)
def sync(self, since=None, timeout=30000):
params = {"timeout": str(timeout), "filter": json.dumps({"room": {"timeline": {"limit": 20}}})}
if since:
params["since"] = since
q = urllib.parse.urlencode(params)
return self._req("GET", f"/_matrix/client/v3/sync?{q}", timeout=timeout // 1000 + 20)
def join(self, room_id):
rid = urllib.parse.quote(room_id, safe="")
return self._req("POST", f"/_matrix/client/v3/join/{rid}", {})
def whoami(self):
return self._req("GET", "/_matrix/client/v3/account/whoami", timeout=10)
def create_dm(self, user_id, name=None):
"""Создаём личную комнату с человеком и приглашаем его."""
payload = {
"is_direct": True,
"preset": "trusted_private_chat",
"invite": [user_id],
}
if name:
payload["name"] = name
return self._req("POST", "/_matrix/client/v3/createRoom", payload, timeout=25)
def direct_rooms(self):
"""Что сервер считает личными комнатами (m.direct)."""
data = self._req("GET", "/_matrix/client/v3/user/" + urllib.parse.quote(self.user_id, safe="")
+ "/account_data/m.direct", timeout=10)
rooms = set()
if isinstance(data, dict):
for ids in data.values():
if isinstance(ids, list):
rooms.update(ids)
return rooms
_ENDINGS = ("ами", "ями", "ого", "его", "ому", "ему", "ыми", "ими", "ая", "яя",
"ое", "ее", "ые", "ие", "ой", "ый", "ий", "ам", "ям", "ах", "ях",
"ов", "ев", "а", "я", "у", "ю", "ы", "и", "е", "о", "ь")
def _stem(word):
"""Грубая основа слова: «статистику» → «статистик»."""
w = word.lower().replace("ё", "е")
for suf in _ENDINGS:
if len(w) > len(suf) + 3 and w.endswith(suf):
return w[: -len(suf)]
return w
class Bot:
"""Бот = учётка + набор команд. Отвечает в личке владельцу."""
name = "bot"
title = "Бот"
room_env = "ROOM"
# как люди называют команды обычными словами
ALIASES = {
"статистика": "stats", "стата": "stats", "сколько": "stats",
"новое": "new", "новинки": "new", "что нового": "new", "последнее": "new",
"поиск": "find", "найди": "find", "ищи": "find",
"сейчас": "now", "смотрят": "now",
"очередь": "queue", "закачки": "queue",
"заявки": "requests", "запросы": "requests",
"диск": "disk", "место": "disk",
"нехватка": "wanted", "не хватает": "wanted",
"файлы": "paths", "пути": "paths",
"карта": "map", "сводка": "digest", "дайджест": "digest",
"пробелы": "gaps", "чего не хватает": "gaps",
"службы": "services", "сервисы": "services",
"содержимое": "content", "контент": "content",
"тревоги": "alerts", "бэкапы": "backups", "бэкап": "backups",
"состояние": "status", "статус": "status",
"индекс": "index", "связи": "link",
"пространство": "space", "альбомы": "stats",
"помощь": "help", "команды": "help", "help": "help",
}
def __init__(self, mx, room_id, dm_rooms=None, owner=None):
self.mx = mx
self.room_id = room_id
self.dm_rooms = set(dm_rooms or [])
self.owner = owner
self.last_sender = None
self.commands = {}
self.register()
def cmd(self, name, help_text):
def deco(fn):
self.commands[name] = (help_text, fn)
return fn
return deco
def register(self):
pass
def help_text(self):
lines = [f"**{self.title}** — что я умею:", ""]
for name, (h, _) in sorted(self.commands.items()):
lines.append(f"• `!{name}` — {h}")
lines.append("")
lines.append("В личной переписке можно без восклицательного знака: "
"просто «статистика» или «найди дюна».")
return "\n".join(lines)
def _parse(self, text, in_dm):
"""Разбираем сообщение: команда, псевдоним или свободный текст.
Возвращает (команда|None, аргумент, исходный_текст).
"""
text = text.strip()
if not text:
return None, "", ""
low = text.lower().strip(" ?!.,")
if text.startswith("!"):
parts = text[1:].split(None, 1)
return parts[0].lower(), (parts[1] if len(parts) > 1 else ""), text
if not in_dm:
return None, "", text
# точное совпадение с псевдонимом или командой
if low in self.ALIASES:
return self.ALIASES[low], "", text
if low in self.commands:
return low, "", text
# по основам слов: «покажи статистику по медиа» → stats
index = {}
for word, cmd in list(self.ALIASES.items()) + [(c, c) for c in self.commands]:
for part in word.split():
index.setdefault(_stem(part), cmd)
words = text.split()
for i, w in enumerate(words):
clean = "".join(ch for ch in w.lower() if ch.isalnum())
if not clean:
continue
cmd = index.get(_stem(clean))
if cmd:
rest = " ".join(words[i + 1:]).strip()
return cmd, rest, text
# не команда — это просьба или вопрос к владельцу
return None, "", text
def _onboard(self, sender):
"""Первый раз от этого человека — прислать инструкцию по направлению."""
try:
import json, os
path = "/var/lib/hub-bots/onboarded.json"
os.makedirs(os.path.dirname(path), exist_ok=True)
try:
data = json.load(open(path, encoding="utf-8"))
except OSError:
data = {}
key = f"{self.name}:{sender}"
if data.get(key):
return None
data[key] = True
json.dump(data, open(path, "w", encoding="utf-8"), ensure_ascii=False, indent=1)
from . import guides
return guides.render(self.name)
except Exception:
return None
def dispatch(self, text, in_dm=False):
cmd, arg, raw = self._parse(text, in_dm)
if (cmd is None and raw.lower().startswith("export")) or cmd == "export":
return self._export((raw[6:].strip() if raw.lower().startswith("export") else arg))
if cmd is None:
if not in_dm:
return None
routed = self._llm_route(raw)
if routed:
return routed
return self.handle_freeform(raw)
if cmd in ("help", "помощь", "?", "start"):
try:
from . import guides
guide = guides.render(self.name)
if guide:
return guide
except Exception:
pass
return self.help_text()
if cmd not in self.commands:
близко = ", ".join(f"`!{c}`" for c in sorted(self.commands)[:6])
return f"Не знаю команду `{cmd}`. Есть: {близко}. Подробнее — `!help`."
try:
return self.commands[cmd][1](arg) or "Готово."
except Exception as e:
return f"Ошибка при `{cmd}`: {str(e)[:200]}"
def _llm_route(self, text):
"""Свободная фраза: спрашиваем модель, что вызвать."""
try:
from . import llm
except Exception:
return None
if not llm.enabled():
return None
res = llm.route(self, text)
if not res:
return None
kind, *rest = res
if kind == "tool":
name, arg = rest[0], rest[1]
try:
return self.commands[name][1](arg) or "Готово."
except Exception as e:
return f"Ошибка при вызове {name}: {str(e)[:150]}"
if kind == "answer":
answer = rest[0]
if not answer:
return None
self._remember(text, answer)
return answer
return None
def _remember(self, question, answer):
"""Пишем диалог в журнал — пригодится для разбора."""
try:
import json, os, datetime
path = "/var/lib/hub-bots/dialog.jsonl"
os.makedirs(os.path.dirname(path), exist_ok=True)
with open(path, "a", encoding="utf-8") as f:
f.write(json.dumps({"at": datetime.datetime.now().isoformat(timespec="seconds"),
"bot": self.name, "q": question[:500],
"a": answer[:500]}, ensure_ascii=False) + "\n")
except Exception:
pass
def handle_freeform(self, text):
"""Свободный текст: это просьба. Передаём владельцу и агенту."""
from . import inbox
num = inbox.add(self.name, self.last_sender or "?", text)
if num is None:
return "Принял, но сегодня уже слишком много сообщений. Попробуйте завтра."
self._export_data("wishes", {
"от": self.last_sender or "неизвестно",
"бот": self.name,
"номер": num,
"текст": text[:1000],
}, tags=["пожелание"])
self.notify_owner(text, num)
return (f"Принял: «{text[:200]}»\n\n"
f"Это не команда, поэтому передал владельцу и агенту — "
f"запись №{num}. Ответ придёт, когда её посмотрят.")
def _export_data(self, collection, payload, tags=None):
"""Отправить данные в ядро — они лягут в папку проекта."""
try:
from . import core_api
import hashlib, time
key = hashlib.sha1(
(self.name + str(payload) + str(time.time())).encode()).hexdigest()[:16]
core_api.save_data(collection, key, payload, tags or [])
return True
except Exception:
return False
def _export(self, arg):
"""Выгрузить коллекцию в папку проекта."""
from . import core_api
collection = (arg or "").strip() or "wishes"
data, err = core_api.export_data(collection, "md")
if err:
return f"Не получилось выгрузить: {err}"
return (f"Выгружено в папку проекта:\n`{data.get('path')}`\n"
f"записей: {data.get('count')}")
def notify_owner(self, text, num):
"""Копия просьбы уходит владельцу, чтобы её не потерять."""
owner = self.owner
if not owner or owner in self.dm_rooms:
return
try:
dm = self.mx.create_dm(owner)
rid = dm.get("room_id")
if rid:
self.mx.join(rid)
self.dm_rooms.add(rid)
self.mx.send_chunked(
rid,
f"**Просьба от {self.last_sender or '?'}** (запись №{num})\n\n{text[:1500]}")
except Exception:
pass
def poll_loop(bot, stop_event, on_ready=None, allowed=None):
"""Слушаем только личные комнаты и только разрешённых людей.
Пока идёт проверка, писать боту может только владелец. Остальным —
вежливый отказ (чтобы не выглядело поломкой).
"""
since = None
first = True
allowed = set(allowed or [])
while not stop_event.is_set():
try:
resp = bot.mx.sync(since=since, timeout=25000)
if "error" in resp:
time.sleep(5)
continue
since = resp.get("next_batch", since)
if first:
first = False
try:
bot.dm_rooms |= bot.mx.direct_rooms()
except Exception:
pass
if on_ready:
on_ready(bot)
continue
rooms = resp.get("rooms", {}).get("join", {})
# приглашение в личку принимаем, если это прямой чат
for rid, invite in (resp.get("rooms", {}).get("invite") or {}).items():
try:
bot.mx.join(rid)
is_direct = any(
ev.get("type") == "m.room.member" and ev.get("content", {}).get("is_direct")
for ev in (invite.get("invite_state", {}) or {}).get("events", []))
if is_direct:
bot.dm_rooms.add(rid)
except Exception:
pass
for rid, data in rooms.items():
if rid not in bot.dm_rooms:
continue
for ev in data.get("timeline", {}).get("events", []):
if ev.get("type") != "m.room.message":
continue
sender = ev.get("sender")
if sender == bot.mx.user_id:
continue
body = ev.get("content", {}).get("body", "")
if not body:
continue
if allowed and sender not in allowed:
bot.mx.send_chunked(
rid,
"Сейчас я на проверке и отвечаю только владельцу. "
"Как только откроют общий доступ — напишу.")
continue
bot.last_sender = sender
intro = bot._onboard(sender)
if intro:
bot.mx.send_chunked(rid, intro)
reply = bot.dispatch(body, in_dm=True)
if reply:
bot.mx.set_typing(rid, False)
bot.mx.send_chunked(rid, reply)
except Exception:
time.sleep(5)