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).
425 lines
17 KiB
Python
425 lines
17 KiB
Python
"""Минимальный клиент 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)
|