From 91df3e60bfb1e5e1db1f59a78f0c4b40cd7c0796 Mon Sep 17 00:00:00 2001 From: buryan-agent Date: Mon, 19 Oct 2026 16:37:38 +0300 Subject: [PATCH] =?UTF-8?q?=D0=A4=D0=BB=D0=BE=D1=82=20Matrix-=D0=B1=D0=BE?= =?UTF-8?q?=D1=82=D0=BE=D0=B2:=20=D0=BC=D0=B5=D0=B4=D0=B8=D0=B0,=20=D1=84?= =?UTF-8?q?=D0=BE=D1=82=D0=BE,=20=D0=BA=D0=BD=D0=B8=D0=B3=D0=B8,=20=D0=B4?= =?UTF-8?q?=D0=BE=D0=BC,=20=D0=B8=D0=BD=D1=84=D1=80=D0=B0=D1=81=D1=82?= =?UTF-8?q?=D1=80=D1=83=D0=BA=D1=82=D1=83=D1=80=D0=B0,=20=D0=BF=D0=BE?= =?UTF-8?q?=D0=B8=D1=81=D0=BA,=20=D0=B4=D0=B0=D0=B9=D0=B4=D0=B6=D0=B5?= =?UTF-8?q?=D1=81=D1=82,=20=D0=BA=D0=B0=D0=BC=D0=B5=D1=80=D1=8B?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Восемь ботов в пространстве Buryan Hub, по комнате на домен. Каждый отвечает на !help списком своих команд и показывает реальные данные: Jellyfin (Items/Counts), Sonarr/Radarr (очередь, диски, нехватка), Seerr (заявки), Prometheus (службы, тревоги), Immich/Calibre/Navidrome и Home Assistant — через pct. Ежедневная сводка в 09:00 (cron) в комнату «Дайджесты». Важное: все библиотеки пусты (0 фильмов, 0 фото, 0 книг, 0 треков), Frigate не развёрнут — боты говорят об этом честно и подсказывают, как наполнить. Диск один, внешних хранилищ нет. Секреты: /etc/hub-bots/bots.env (600), /root/hub-bots/ALL-SECRETS.txt (600), зашифрованная копия ops/secrets-enc/hub-bots-secrets.age. --- docs/HUB-BOTS.md | 106 ++++++ ops/bots/README.md | 29 ++ ops/bots/digest.py | 40 +++ ops/bots/hub/__init__.py | 1 + ops/bots/hub/bots.py | 475 +++++++++++++++++++++++++++ ops/bots/hub/catalog.py | 62 ++++ ops/bots/hub/local.py | 146 ++++++++ ops/bots/hub/main.py | 97 ++++++ ops/bots/hub/matrix.py | 160 +++++++++ ops/bots/hub/sources.py | 259 +++++++++++++++ ops/bots/hub/util.py | 88 +++++ ops/bots/selftest.py | 47 +++ ops/secrets-enc/hub-bots-secrets.age | 14 + 13 files changed, 1524 insertions(+) create mode 100644 docs/HUB-BOTS.md create mode 100644 ops/bots/README.md create mode 100755 ops/bots/digest.py create mode 100644 ops/bots/hub/__init__.py create mode 100644 ops/bots/hub/bots.py create mode 100644 ops/bots/hub/catalog.py create mode 100644 ops/bots/hub/local.py create mode 100644 ops/bots/hub/main.py create mode 100644 ops/bots/hub/matrix.py create mode 100644 ops/bots/hub/sources.py create mode 100644 ops/bots/hub/util.py create mode 100644 ops/bots/selftest.py create mode 100644 ops/secrets-enc/hub-bots-secrets.age diff --git a/docs/HUB-BOTS.md b/docs/HUB-BOTS.md new file mode 100644 index 0000000..1cf395c --- /dev/null +++ b/docs/HUB-BOTS.md @@ -0,0 +1,106 @@ +# Buryan Hub: флот ботов и контентная платформа + +Что сделано 19.10.2026: боты в Matrix, пространство с комнатами, единая карта +сервисов, ежедневная сводка, ключи в одном месте. + +--- + +## 1. Важное открытие: библиотеки пусты + +Прежде чем строить «контентную архитектуру», проверил, что в сервисах есть: + +| Сервис | Содержимое | +|---|---| +| Jellyfin (медиатека) | **0** фильмов, 0 сериалов, 0 серий, 0 альбомов | +| Plex | папка `/opt/plex/media` пуста | +| Navidrome (музыка) | **0** треков, 0 альбомов | +| Immich (фото) | **0** снимков, 0 альбомов | +| Calibre (книги) | **0** книг | +| Home Assistant | **8** сущностей | +| Frigate | **не развёрнут** | + +Диск один (NVMe 476 ГБ), внешних хранилищ нет. То есть платформа построена, +но контентом не наполнена — интеграция пока показывает честные нули +и подсказки, как наполнить. + +**Что нужно, чтобы ожило:** + +1. **Медиа** — положить файлы в `/media/movies`, `/media/series`, `/media/music` + (CT 103) и запустить сканирование. Для автоматических загрузок — + настроить в Sonarr/Radarr клиент загрузки (qBittorrent/ Transmission) + и индексаторы в Prowlarr. +2. **Фото** — поставить приложение Immich на телефоны, включить автозагрузку. +3. **Книги** — загрузить через `books.buryans.ru`. +4. **Дом** — добавить устройства в Home Assistant. +5. **Frigate** — нужны RTSP-адреса камер; без них сервер наблюдения не имеет смысла. + +--- + +## 2. Пространство и комнаты + +Пространство **Buryan Hub** в Matrix, внутри 9 комнат: + +| Комната | Бот | Что там | +|---|---|---| +| Медиа | `@media` | фильмы, сериалы, очередь загрузок, заявки | +| Фото | `@photo` | Immich: снимки, альбомы | +| Книги | `@book` | библиотека, поиск, новинки | +| Дом | `@home` | Home Assistant: сущности, состояние | +| Инфраструктура | `@infra` | службы, тревоги, диски, резервные копии, состав библиотек | +| Поиск | `@search` | поиск по медиа, книгам и документам сразу | +| Дайджесты | `@digest` | ежедневная сводка в 09:00 и карта платформы | +| Камеры | `@cam` | Frigate (когда появится) | + +Люди приглашены: `@akadmin`, `@polina`, `@elena`, `@nikita`, `@sergey`, `@alextest`. + +## 3. Команды ботов + +У каждого бота `!help` показывает свои команды. Коротко: + +| Бот | Команды | +|---|---| +| media | `!stats` `!new` `!find <текст>` `!now` `!queue` `!requests` `!disk` `!wanted` `!paths` | +| photo | `!stats` `!space` | +| book | `!stats` `!new` `!find <текст>` | +| home | `!stats` `!status` | +| infra | `!status` `!alerts` `!disk` `!backups` `!content` `!services` | +| search | `!s <текст>` | +| digest | `!digest` `!map` | +| cam | `!status` | + +## 4. Как это устроено + +``` +/opt/hub-bots/ ← код на узле Proxmox + hub/ + matrix.py клиент Matrix: отправка, длинный опрос + sources.py клиенты сервисов (Jellyfin, Sonarr, Radarr, Seerr, Prometheus) + local.py чтение баз через pct (Navidrome, Calibre, Immich, HA) + catalog.py карта сервисов и состав библиотек + bots.py все боты и их команды + main.py запуск флота + digest.py ежедневная сводка (cron 09:00) +/etc/hub-bots/bots.env настройки и ключи (600) +/etc/systemd/system/hub-bots.service +``` + +Почему на узле, а не в контейнере: боты читают базы сервисов через `pct exec` +(Navidrome, Calibre, Immich, Home Assistant) — из контейнера так нельзя. + +Служба: `systemctl status hub-bots`, лог `/var/log/hub-bots.log`. + +## 5. Где ключи + +* `/etc/hub-bots/bots.env` — рабочие ключи (600). +* `/root/hub-bots/ALL-SECRETS.txt` — **все** ключи одним файлом (600). +* `ops/secrets-enc/hub-bots-secrets.age` — то же, зашифровано age (в репозитории). + Расшифровать: `SOPS_AGE_KEY_FILE=/root/.buryan-age-key sops -d ...`. + +## 6. Что дальше (по приоритету) + +1. **Наполнить библиотеки** — без контента боты показывают нули. +2. **Уведомления** Seerr/Sonarr → комната «Медиа» (вебхук в n8n или напрямую). +3. **Frigate** — как только будут камеры. +4. **Кросс-связи**: книга → экранизация (Calibre ↔ Jellyfin), фото → место + (Immich ↔ Home Assistant), музыка → исполнитель в медиатеке. +5. **Утренняя сводка уже включена** — посмотрите комнату «Дайджесты». diff --git a/ops/bots/README.md b/ops/bots/README.md new file mode 100644 index 0000000..3c82987 --- /dev/null +++ b/ops/bots/README.md @@ -0,0 +1,29 @@ +# Флот Matrix-ботов + +Восемь ботов: медиа, фото, книги, дом, инфраструктура, поиск, дайджест, камеры. + +## Установка + +``` +mkdir -p /opt/hub-bots /etc/hub-bots +cp -a hub /opt/hub-bots/ +cp digest.py selftest.py /opt/hub-bots/ +# настройки: /etc/hub-bots/bots.env (токены ботов, комнаты, ключи сервисов) +systemctl enable --now hub-bots +``` + +Служба: `/etc/systemd/system/hub-bots.service`. +Ежедневная сводка: `/etc/cron.d/hub-digest` (09:00). + +## Почему на узле + +Боты читают базы сервисов через `pct exec` (Navidrome, Calibre, Immich, +Home Assistant). Из контейнера в контейнер так не попасть. + +## Проверка + +``` +python3 /opt/hub-bots/selftest.py # ответы ботов без Matrix +systemctl status hub-bots +tail -f /var/log/hub-bots.log +``` diff --git a/ops/bots/digest.py b/ops/bots/digest.py new file mode 100755 index 0000000..ffa49dd --- /dev/null +++ b/ops/bots/digest.py @@ -0,0 +1,40 @@ +#!/usr/bin/env python3 +"""Ежедневная сводка в комнату дайджеста.""" +import sys + +sys.path.insert(0, "/opt/hub-bots") + +from hub.main import ENV # noqa: E402 (загружает настройки) +from hub.bots import DigestBot # noqa: E402 +from hub.matrix import Matrix # noqa: E402 + + +class Null: + user_id = "@digest:local" + + def send_chunked(self, *a, **k): + return {} + + def send(self, *a, **k): + return {} + + def set_typing(self, *a, **k): + return {} + + +def main(): + token = ENV.get("DIGEST_TOKEN") + user = ENV.get("DIGEST_USER") + room = ENV.get("DIGEST_ROOM") + if not (token and user and room): + print("нет настроек дайджеста") + return 1 + text = DigestBot(Null(), room).build() + mx = Matrix(ENV.get("HS", "https://matrix.buryans.ru"), user, token) + mx.send_chunked(room, text) + print("сводка отправлена") + return 0 + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/ops/bots/hub/__init__.py b/ops/bots/hub/__init__.py new file mode 100644 index 0000000..04e1802 --- /dev/null +++ b/ops/bots/hub/__init__.py @@ -0,0 +1 @@ +"""Пакет ботов Buryan Hub.""" diff --git a/ops/bots/hub/bots.py b/ops/bots/hub/bots.py new file mode 100644 index 0000000..0a355db --- /dev/null +++ b/ops/bots/hub/bots.py @@ -0,0 +1,475 @@ +"""Флот ботов: у каждого свой домен и свои команды.""" +import datetime + +from . import catalog, local, sources, util +from .matrix import Bot +from .sources import CFG, RADARR, SONARR, Jellyfin, Prom, Seerr + + +def _fmt_item(it): + year = it.get("ProductionYear") + name = it.get("Name", "без названия") + kind = {"Movie": "фильм", "Series": "сериал", "Audio": "трек"}.get(it.get("Type"), it.get("Type", "")) + return f"{name}" + (f" ({year})" if year else "") + (f" — {kind}" if kind else "") + + +def _empty_hint(): + return ("\n\n_Библиотека пуста._ Наполнить можно так: " + "положить файлы в папку сервиса и запустить сканирование.") + + +class MediaBot(Bot): + name = "media" + title = "Медиа" + room_env = "MEDIA_ROOM" + + def register(self): + jf = Jellyfin() + seerr = Seerr() + + self.cmd("stats", "что есть в медиатеке: фильмы, сериалы, музыка")(lambda a: self._stats(jf)) + self.cmd("new", "что добавилось последним")(lambda a: self._new(jf)) + self.cmd("find", "поиск по медиатеке: `!find матрица`")(lambda a: self._find(jf, a)) + self.cmd("now", "кто что смотрит прямо сейчас")(lambda a: self._now(jf)) + self.cmd("queue", "очередь загрузок в Sonarr и Radarr")(lambda a: self._queue()) + self.cmd("requests", "последние заявки в Seerr")(lambda a: self._requests(seerr)) + self.cmd("disk", "место на дисках медиасервисов")(lambda a: self._disk()) + self.cmd("wanted", "сколько ещё не найдено")(lambda a: self._wanted()) + self.cmd("paths", "где лежат файлы и куда их класть")(lambda a: self._paths()) + + def _stats(self, jf): + c = jf.counts() + info, _ = jf.info() + names = {"Movie": "Фильмы", "Series": "Сериалы", "Episode": "Серии", + "Audio": "Треки", "MusicAlbum": "Альбомы"} + lines = ["**Медиатека**", ""] + total = 0 + for k, v in c.items(): + lines.append(f"• {names.get(k, k)}: {v}") + total += v or 0 + if info: + lines.append(f"\nСервер: {info.get('ServerName')} {info.get('Version')}") + + nav = local.Navidrome().counts() + if nav and not nav[1]: + lines.append(f"• Музыка (Navidrome): {nav[0]['albums']} альбомов, " + f"{nav[0]['tracks']} треков, {nav[0]['artists']} исполнителей") + total += nav[0]["tracks"] + + if total == 0: + lines.append(_empty_hint()) + return "\n".join(lines) + + def _new(self, jf): + items, err = jf.recent(10) + if err: + return f"Jellyfin не ответил: {err}" + if not items: + return "В медиатеке пока ничего нет." + _empty_hint() + lines = ["**Последние поступления**", ""] + for it in items: + lines.append(f"• {_fmt_item(it)}") + return "\n".join(lines) + + def _find(self, jf, term): + if not term: + return "Напишите, что искать: `!find дюна`" + items, err = jf.search(term) + if err: + return f"Jellyfin не ответил: {err}" + if not items: + return f"По запросу «{term}» ничего не нашлось." + lines = [f"**Найдено по «{term}»**", ""] + for it in items: + lines.append(f"• {_fmt_item(it)}") + return "\n".join(lines) + + def _now(self, jf): + sess, err = jf.sessions() + if err: + return f"Jellyfin не ответил: {err}" + if not sess: + return "Сейчас никто ничего не смотрит." + lines = ["**Смотрят сейчас**", ""] + for s in sess: + item = s.get("NowPlayingItem", {}) + user = s.get("UserName", "?") + pos = s.get("PlayState", {}).get("PositionTicks", 0) / 10_000_000 + lines.append(f"• {user}: {item.get('Name')} — {util.human_time(pos)}") + return "\n".join(lines) + + def _queue(self): + lines = ["**Очередь загрузок**", ""] + for svc in (SONARR, RADARR): + total, err = svc.queue() + lines.append(f"• {svc.name}: {'—' if err else total}") + return "\n".join(lines) + + def _requests(self, seerr): + reqs, err = seerr.requests(6) + if err: + return f"Seerr не ответил: {err}" + if not reqs: + return "Заявок пока нет. Заказать можно на https://ombi.buryans.ru" + lines = ["**Последние заявки**", ""] + for r in reqs: + media = r.get("media", {}) or {} + title = media.get("title") or media.get("name") or "?" + status = {1: "ожидает", 2: "одобрено", 3: "отклонено"}.get(r.get("status"), "?") + who = (r.get("requestedBy") or {}).get("displayName", "?") + lines.append(f"• {title} — {status} (просил {who})") + return "\n".join(lines) + + def _disk(self): + lines = ["**Диски**", ""] + for svc in (SONARR, RADARR): + disks, err = svc.diskspace() + if err: + lines.append(f"• {svc.name}: ошибка") + continue + for d in disks: + free = d.get("freeSpace", 0) + total = d.get("totalSpace", 1) + pct = 100 * free / total if total else 0 + lines.append(f"• {svc.name} {d.get('path','?')}: свободно " + f"{util.human_bytes(free)} ({pct:.0f}%)") + return "\n".join(lines) + + def _wanted(self): + lines = ["**Чего не хватает**", ""] + for svc in (SONARR, RADARR): + n, err = svc.wanted() + lines.append(f"• {svc.name}: {'—' if err else f'{n} позиций'}") + return "\n".join(lines) + + def _paths(self): + return ("**Куда класть файлы**\n\n" + "• Jellyfin: `/media/movies`, `/media/series`, `/media/music` (CT 103)\n" + "• Plex: `/opt/plex/media` (CT 116)\n" + "• Музыка: папка музыки (CT 125)\n\n" + "После копирования запустите в Jellyfin «Сканировать библиотеку».") + + +class PhotoBot(Bot): + name = "photo" + title = "Фото" + room_env = "PHOTO_ROOM" + + def register(self): + self.cmd("stats", "сколько снимков, альбомов и людей в Immich")(lambda a: self._stats()) + self.cmd("space", "сколько занимает база фото")(lambda a: self._space()) + + def _stats(self): + c, err = local.ImmichDb().counts() + if err: + return f"Не смог прочитать базу Immich: {err}" + lines = ["**Фотографии**", "", + f"• Снимков: {c['assets']}", + f"• Альбомов: {c['albums']}", + f"• Пользователей: {c['users']}", + "", "Адрес: https://immich.buryans.ru"] + if c["assets"] == 0: + lines.append("\n_Фотографий пока нет._ Загрузите с телефона через приложение Immich — " + "оно само синхронизирует снимки.") + return "\n".join(lines) + + def _space(self): + out, err = local.pct_exec(151, ["su", "-", "postgres", "-c", + "psql -d immich_db -tAc \"select pg_size_pretty(pg_database_size('immich_db'))\""]) + if err: + return f"Не удалось узнать размер: {err}" + return f"База Immich занимает {out}. Снимки лежат в хранилище рядом с базой." + + +class BookBot(Bot): + name = "book" + title = "Книги" + room_env = "BOOK_ROOM" + + def register(self): + books = local.Books() + self.cmd("stats", "сколько книг в библиотеке")(lambda a: self._stats(books)) + self.cmd("new", "последние поступления")(lambda a: self._new(books)) + self.cmd("find", "поиск книги: `!find стругацкие`")(lambda a: self._find(books, a)) + + def _stats(self, books): + c, err = books.counts() + if err: + return f"Библиотека недоступна: {err}" + lines = [f"**Библиотека**\n\n• Книг: {c['books']}\n\nЧитать: https://books.buryans.ru"] + if c["books"] == 0: + lines.append("\n_Книг пока нет._ Добавить: https://books.buryans.ru → " + "«Загрузить книгу», либо положить файлы в каталог библиотеки.") + return "\n".join(lines) + + def _new(self, books): + rows, err = books.recent(8) + if err: + return f"Не удалось получить список: {err}" + if not rows: + return "Библиотека пуста." + lines = ["**Новые книги**", ""] + for r in rows: + lines.append(f"• {r['title']} — {r['author']}") + return "\n".join(lines) + + def _find(self, books, term): + if not term: + return "Что искать? `!find пелевин`" + rows, err = books.search(term) + if err: + return f"Поиск не сработал: {err}" + if not rows: + return f"По запросу «{term}» ничего нет." + lines = [f"**Книги по «{term}»**", ""] + for r in rows: + lines.append(f"• {r['title']} — {r['author']}") + return "\n".join(lines) + + +class HomeBot(Bot): + name = "home" + title = "Дом" + room_env = "HOME_ROOM" + + def register(self): + self.cmd("stats", "сколько устройств и датчиков в Home Assistant")(lambda a: self._stats()) + self.cmd("status", "кратко о состоянии дома")(lambda a: self._status()) + + def _stats(self): + data, err = local.HomeDb().entities() + if err: + return f"Не смог прочитать реестр HA: {err}" + lines = ["**Дом**", "", f"• Устройств и сущностей: {data['total']}"] + if data["kinds"]: + lines.append("• По типам: " + ", ".join(data["kinds"].split("|"))) + lines.append("\nУправление: https://home.buryans.ru") + if data["total"] < 20: + lines.append("\n_Устройств мало._ Добавить: Home Assistant → Настройки → " + "Устройства и службы → «Добавить интеграцию».") + return "\n".join(lines) + + def _status(self): + data, err = local.HomeDb().states() + if err: + return f"Не удалось прочитать состояние: {err}" + return (f"**Состояние дома**\n\n• Запомненных состояний: {data['restored']}\n\n" + "Полная картина — на панели: https://home.buryans.ru") + + +class InfraBot(Bot): + name = "infra" + title = "Инфраструктура" + room_env = "INFRA_ROOM" + + def register(self): + prom = Prom() + self.cmd("status", "какие службы живы, а какие нет")(lambda a: self._status(prom)) + self.cmd("alerts", "активные тревоги")(lambda a: self._alerts(prom)) + self.cmd("disk", "место на дисках")(lambda a: self._disk(prom)) + self.cmd("backups", "последние резервные копии")(lambda a: self._backups()) + self.cmd("content", "что лежит в библиотеках")(lambda a: self._content()) + self.cmd("services", "полный список служб и адресов")(lambda a: self._services()) + + def _status(self, prom): + targets, err = prom.targets() + if err: + return f"Prometheus не ответил: {err}" + up = [t for t in targets if t.get("health") == "up"] + down = [t for t in targets if t.get("health") != "up"] + lines = [f"**Службы**: {len(up)} в норме, {len(down)} проблемных", ""] + for t in down[:12]: + job = t["labels"].get("job", "?") + app = t["labels"].get("app", "") + lines.append(f"• ⚠ {job} {app} — {t.get('health')}") + return "\n".join(lines) + + def _alerts(self, prom): + alerts, err = prom.alerts() + if err: + return f"Не смог получить тревоги: {err}" + if not alerts: + return "Активных тревог нет." + lines = ["**Тревоги**", ""] + for a in alerts: + lines.append(f"• {a.get('labels', {}).get('alertname')} — {a.get('state')}") + return "\n".join(lines) + + def _disk(self, prom): + q = '(node_filesystem_avail_bytes{mountpoint="/"} * 100 / node_filesystem_size_bytes{mountpoint="/"})' + v, err = prom.query(q + " < 15") + if err: + return f"Не удалось: {err}" + host = catalog.host_df() + lines = ["**Место**", ""] + if host: + lines.append(f"• Узел: {host.split()[3] if len(host.split()) > 3 else '—'} свободно " + f"({host.split()[4] if len(host.split()) > 4 else '—'})") + if v: + lines.append(f"• Узлов с запасом меньше 15%: {int(v)}") + else: + lines.append("• Все узлы имеют больше 15% запаса") + return "\n".join(lines) + + def _backups(self): + out, err = local.pct_exec(10, ["sh", "-c", "ls -t /mnt/backups/dump/*.tar.zst 2>/dev/null | head -3"]) + if err or not out: + try: + import subprocess + r = subprocess.run(["bash", "-c", "ls -t /mnt/backups/dump/*.tar.zst 2>/dev/null | head -3"], + capture_output=True, text=True, timeout=15) + out = r.stdout.strip() + except Exception: + out = "" + if not out: + return "Свежих архивов не нашёл в /mnt/backups." + lines = ["**Последние архивы**", ""] + for line in out.splitlines(): + lines.append(f"• {line.split('/')[-1]}") + return "\n".join(lines) + + def _content(self): + c = catalog.content_state() + jf = c.get("jellyfin") or {} + nav = c.get("navidrome") or {} + books = c.get("books") or {} + img = c.get("immich") or {} + ha = c.get("home") or {} + return ("**Что лежит в библиотеках**\n\n" + f"• Фильмы: {jf.get('Movie', 0)}\n" + f"• Сериалы: {jf.get('Series', 0)}\n" + f"• Музыка: {nav.get('tracks', 0)} треков / {nav.get('albums', 0)} альбомов\n" + f"• Книги: {books.get('books', 0)}\n" + f"• Фото: {img.get('assets', 0)}\n" + f"• Дом: {ha.get('total', 0)} сущностей") + + def _services(self): + lines = ["**Все службы**", ""] + for name, addr, domain, holds, fill in catalog.SERVICES: + link = f"https://{domain}" if domain and domain != "—" else addr + lines.append(f"• **{name}** — {holds}\n {link} · {addr}") + return "\n".join(lines) + + +class SearchBot(Bot): + name = "search" + title = "Поиск" + room_env = "SEARCH_ROOM" + + def register(self): + self.cmd("s", "поиск по всему: `!s дюна`")(lambda a: self._search(a)) + + def _search(self, term): + if not term: + return "Что искать? Например `!s дюна`" + out = [f"**Поиск «{term}»**", ""] + found = False + + items, err = Jellyfin().search(term, 5) + if items: + found = True + out.append("**Медиа**") + for it in items: + out.append(f"• {_fmt_item(it)}") + elif err: + out.append(f"Медиа: ошибка — {err}") + + rows, err = local.Books().search(term, 5) + if rows: + found = True + out.append("\n**Книги**") + for r in rows: + out.append(f"• {r['title']} — {r['author']}") + + docs, err = util.get( + f"{CFG.paperless_url}/api/documents/?query={util.quote(term)}&page_size=5", + {"Authorization": f"Token {CFG.paperless_token}"}, ttl=60) + if docs and docs.get("results"): + found = True + out.append("\n**Документы**") + for d in docs["results"]: + out.append(f"• {d.get('title')}") + + if not found: + out.append("Ничего не нашлось. Попробуйте другое слово.") + return "\n".join(out) + + +class DigestBot(Bot): + name = "digest" + title = "Дайджест" + room_env = "DIGEST_ROOM" + + def register(self): + self.cmd("digest", "сводка по всем сервисам прямо сейчас")(lambda a: self.build()) + self.cmd("map", "карта платформы: что где живёт")(lambda a: self._map()) + + def build(self): + parts = [f"**Сводка · {datetime.date.today().strftime('%d.%m.%Y')}**", ""] + c = catalog.content_state() + + jf = c.get("jellyfin") or {} + parts.append(f"**Медиа**: {jf.get('Movie', 0)} фильмов, {jf.get('Series', 0)} сериалов, " + f"{jf.get('MusicAlbum', 0)} альбомов") + + nav = c.get("navidrome") or {} + parts.append(f"**Музыка**: {nav.get('albums', 0)} альбомов, {nav.get('tracks', 0)} треков") + + img = c.get("immich") or {} + parts.append(f"**Фото**: {img.get('assets', 0)} снимков в {img.get('albums', 0)} альбомах") + + books = c.get("books") or {} + parts.append(f"**Книги**: {books.get('books', 0)}") + + ha = c.get("home") or {} + parts.append(f"**Дом**: {ha.get('total', 0)} сущностей") + + prom = Prom() + targets, err = prom.targets() + if targets: + down = sum(1 for t in targets if t.get("health") != "up") + parts.append(f"**Службы**: {len(targets) - down} в норме, {down} проблемных") + alerts, _ = prom.alerts() + parts.append(f"**Тревоги**: {len(alerts)} активных") + + return "\n".join(parts) + + def _map(self): + lines = ["**Карта платформы**", "", "Один вход: Authentik. Внутри — домены, боты, мониторинг.", ""] + groups = { + "Медиа": ["Jellyfin", "Plex", "Sonarr", "Radarr", "Prowlarr", "Bazarr", "Seerr"], + "Контент": ["Immich", "Calibre-Web", "Paperless", "Home Assistant"], + "Сервисы": ["Nextcloud", "Vaultwarden", "Gitea", "Matrix"], + "Наблюдение": ["Prometheus", "Grafana", "Loki", "Uptime Kuma"], + "Автоматизация": ["n8n", "Node-RED"], + } + by_name = {s[0]: s for s in catalog.SERVICES} + for group, names in groups.items(): + lines.append(f"**{group}**") + for n in names: + s = by_name.get(n) + if s: + lines.append(f"• {s[0]} — {s[3]} ({s[2] if s[2] != '—' else s[1]})") + lines.append("") + lines.append("Подробности: `!services` у бота инфраструктуры, состав библиотек — `!content`.") + return "\n".join(lines) + + +class CamBot(Bot): + name = "cam" + title = "Камеры" + room_env = "CAM_ROOM" + + def register(self): + self.cmd("status", "есть ли подключённый сервер наблюдения")(lambda a: self._status()) + + def _status(self): + if not CFG.frigate_url: + return ("**Камеры**\n\n" + "Frigate пока не развёрнут — сервер наблюдения не найден ни в одном контейнере.\n\n" + "Чтобы я начал показывать события, нужно:\n" + "1. Развернуть Frigate (нужны RTSP-адреса камер).\n" + "2. Дать адрес Frigate и его ключ.\n\n" + "После этого здесь появятся: список камер, события движения, " + "детекция людей и машин, ссылки на записи.") + return "Frigate отвечает — уточните, что показать." diff --git a/ops/bots/hub/catalog.py b/ops/bots/hub/catalog.py new file mode 100644 index 0000000..3333a65 --- /dev/null +++ b/ops/bots/hub/catalog.py @@ -0,0 +1,62 @@ +"""Общие сведения о системе: что где живёт и чем наполняется.""" +import subprocess + +# Единый каталог сервисов: имя → адрес, домен, что хранит, как наполняется. +SERVICES = [ + ("Jellyfin", "192.168.1.103:8096", "media.buryans.ru", "фильмы, сериалы, музыка", + "папки /media/{movies,series,music} в CT 103"), + ("Plex", "192.168.1.116:32400", "plex.buryans.ru", "фильмы, сериалы", + "папки /opt/plex/media в CT 116"), + ("Navidrome", "192.168.1.125:4533", "music.buryans.ru", "музыка", + "папка музыки в CT 125"), + ("Sonarr", "192.168.1.117:8989", "sonarr.buryans.ru", "сериалы, загрузки", + "автоматически по заявкам"), + ("Radarr", "192.168.1.118:7878", "radarr.buryans.ru", "фильмы, загрузки", + "автоматически по заявкам"), + ("Prowlarr", "192.168.1.119:9696", "prowlarr.buryans.ru", "индексаторы", "настройка вручную"), + ("Bazarr", "192.168.1.120:6767", "bazarr.buryans.ru", "субтитры", "автоматически"), + ("Seerr", "192.168.1.121:5055", "ombi.buryans.ru", "заявки на фильмы и сериалы", "люди просят — arr качают"), + ("Immich", "192.168.1.104:2283", "immich.buryans.ru", "фотографии и видео", "загрузка с телефонов"), + ("Calibre-Web", "192.168.1.240:8083", "books.buryans.ru", "книги", + "/opt/books/library в CT 111"), + ("Paperless", "192.168.1.105:8000", "docs.buryans.ru", "документы", "сканы и загрузка"), + ("Home Assistant", "192.168.1.106:8123", "home.buryans.ru", "умный дом", "устройства и датчики"), + ("Uptime Kuma", "192.168.1.107:3001", "status.buryans.ru", "проверки доступности", "мониторы"), + ("Prometheus", "192.168.1.134:9090", "—", "метрики", "сбор с экспортёров"), + ("Grafana", "192.168.1.113:3000", "grafana.buryans.ru", "графики", "метрики и логи"), + ("Loki", "192.168.1.113:3100", "—", "логи", "promtail со всех узлов"), + ("n8n", "192.168.1.108:9105", "n8n.buryans.ru", "автоматизация", "сценарии"), + ("Node-RED", "192.168.1.108:1880", "flow.buryans.ru", "событийные цепочки", "потоки"), + ("Matrix", "192.168.1.155:8008", "matrix.buryans.ru", "общение, боты", "комнаты"), + ("Nextcloud", "192.168.1.109:8080", "files.buryans.ru", "файлы", "загрузка"), + ("Vaultwarden", "192.168.1.109:8081", "vault.buryans.ru", "пароли", "вручную"), + ("Gitea", "192.168.1.140:3000", "git.buryans.ru", "код", "git push"), + ("Authentik", "192.168.1.114:9000", "authentik.buryans.ru", "вход и пользователи", "единый вход"), +] + + +def host_df(path="/"): + """Свободное место на узле.""" + if path == "/": + try: + out = subprocess.run(["df", "-h", "/"], capture_output=True, text=True, timeout=10) + return out.stdout.splitlines()[-1] if out.returncode == 0 else None + except Exception: + return None + return None + + +def content_state(): + """Сколько всего лежит в библиотеках — сводка для бота.""" + from .local import Books, HomeDb, ImmichDb, Navidrome + from .sources import Jellyfin + + out = {} + c = Jellyfin().counts() + out["jellyfin"] = c + out["navidrome"] = (Navidrome().counts() or ({}, None))[0] + out["books"] = (Books().counts() or ({}, None))[0] + out["immich"] = (ImmichDb().counts() or ({}, None))[0] + ha = HomeDb().entities() + out["home"] = ha[0] if ha else None + return out diff --git a/ops/bots/hub/local.py b/ops/bots/hub/local.py new file mode 100644 index 0000000..749d7b1 --- /dev/null +++ b/ops/bots/hub/local.py @@ -0,0 +1,146 @@ +"""Чтение данных сервисов через pct (сервис живёт на узле Proxmox).""" +import subprocess + + +def pct_exec(ct, args, timeout=25): + """Выполнить команду внутри контейнера Proxmox.""" + cmd = ["pct", "exec", str(ct), "--"] + args + try: + out = subprocess.run(cmd, capture_output=True, text=True, timeout=timeout) + if out.returncode != 0: + return None, (out.stderr or out.stdout).strip()[:160] + return out.stdout.strip(), None + except Exception as e: + return None, str(e)[:120] + + +def docker_sqlite(ct, container, db, sql, timeout=25): + return pct_exec(ct, ["docker", "exec", container, "sqlite3", db, sql], timeout=timeout) + + +class Navidrome: + """Музыка: считаем по базе, без пароля.""" + + def counts(self): + out, err = docker_sqlite( + 125, "navidrome", "/data/navidrome.db", + "select (select count(*) from artist)||'|'||(select count(*) from album)" + "||'|'||(select count(*) from media_file)") + if err: + return None, err + try: + a, al, m = (int(x) for x in out.split("|")) + return {"artists": a, "albums": al, "tracks": m}, None + except Exception: + return None, f"странный ответ: {out[:60]}" + + def size(self): + out, err = pct_exec(125, ["sh", "-c", "du -sh /opt/music-lxc/music 2>/dev/null | cut -f1"]) + return out or "—" + + +class Books: + """Книги: библиотека Calibre, читаем через python3 (sqlite3 в модуле).""" + + DB = "/opt/books/library/metadata.db" + + _COUNT = ("import sqlite3;" + "c=sqlite3.connect('%s');" + "print(c.execute('select count(*) from books').fetchone()[0])" % DB) + + _RECENT = ("import sqlite3,sys;" + "c=sqlite3.connect('%s');" + "rows=c.execute('select b.title, ifnull((select a.name from authors a " + "join books_authors_link l on l.author=a.id where l.book=b.id limit 1), chr(45)) " + "from books b order by b.id desc limit ?', (int(sys.argv[1]),)).fetchall();" + "[print(r[0]+chr(124)+(r[1] or chr(45))) for r in rows]" % DB) + + _SEARCH = ("import sqlite3,sys;" + "c=sqlite3.connect('%s');" + "rows=c.execute('select b.title, ifnull((select a.name from authors a " + "join books_authors_link l on l.author=a.id where l.book=b.id limit 1), chr(45)) " + "from books b where b.title like ? limit ?', (chr(37)+sys.argv[1]+chr(37), int(sys.argv[2]))).fetchall();" + "[print(r[0]+chr(124)+(r[1] or chr(45))) for r in rows]" % DB) + + def counts(self): + out, err = pct_exec(111, ["python3", "-c", self._COUNT]) + if err: + return None, err + try: + return {"books": int(out)}, None + except ValueError: + return None, f"странный ответ: {out[:60]}" + + def _rows(self, out): + rows = [] + for line in (out or "").splitlines(): + parts = line.split("|") + if len(parts) >= 2: + rows.append({"title": parts[0], "author": parts[1] or "—"}) + return rows + + def recent(self, limit=8): + out, err = pct_exec(111, ["python3", "-c", self._RECENT, str(limit)]) + if err: + return [], err + return self._rows(out), None + + def search(self, term, limit=8): + out, err = pct_exec(111, ["python3", "-c", self._SEARCH, term, str(limit)]) + if err: + return [], err + return self._rows(out), None + + +class ImmichDb: + def counts(self): + out, err = pct_exec(151, ["su", "-", "postgres", "-c", + "psql -d immich_db -tAc \"select (select count(*) from asset)" + "||'|'||(select count(*) from album)||'|'||(select count(*) from \\\"user\\\")\""]) + if err: + return None, err + try: + a, al, u = (int(x) for x in out.split("|")) + return {"assets": a, "albums": al, "users": u}, None + except Exception: + return None, f"странный ответ: {out[:60]}" + + +class HomeDb: + """Home Assistant: читаем реестр сущностей (только чтение).""" + + def entities(self): + out, err = pct_exec(106, ["docker", "exec", "homeassistant", "sh", "-c", + "python3 -c \"import json,collections;" + "d=json.load(open('/config/.storage/core.entity_registry'))['data']['entities'];" + "c=collections.Counter(e['entity_id'].split('.')[0] for e in d);" + "print(len(d));print('|'.join(f'{k}={v}' for k,v in c.most_common(10)))\""]) + if err: + return None, err + lines = out.splitlines() + try: + total = int(lines[0]) + except (IndexError, ValueError): + return None, "не удалось разобрать ответ" + kinds = lines[1] if len(lines) > 1 else "" + return {"total": total, "kinds": kinds}, None + + def states(self): + out, err = pct_exec(106, ["docker", "exec", "homeassistant", "sh", "-c", + "python3 -c \"import json;" + "d=json.load(open('/config/.storage/core.restore_state'))['data'];" + "s=[x for x in d if isinstance(x,dict) and 'state' in x];" + "print(len(s))\""]) + if err: + return None, err + return {"restored": int(out or 0)}, None + + +class Disks: + """Свободное место по узлу и контейнерам.""" + + def host(self): + out, err = pct_exec(10, ["df", "-h", "/"]) + if err: + return None, err + return out.splitlines()[-1] if out else None, None diff --git a/ops/bots/hub/main.py b/ops/bots/hub/main.py new file mode 100644 index 0000000..a995540 --- /dev/null +++ b/ops/bots/hub/main.py @@ -0,0 +1,97 @@ +"""Точка входа: поднимаем всех ботов и слушаем комнаты.""" +import os +import signal +import sys +import threading +import time + +ENV_PATH = os.environ.get("HUB_ENV", "/etc/hub-bots/bots.env") + + +def load_env(path=ENV_PATH): + """Читаем файл настроек и сразу кладём в окружение — до импорта источников.""" + env = {} + try: + with open(path, encoding="utf-8") as f: + for line in f: + line = line.strip() + if not line or line.startswith("#") or "=" not in line: + continue + k, v = line.split("=", 1) + env[k.strip()] = v.strip() + except OSError as e: + print(f"нет файла настроек {path}: {e}", flush=True) + for k, v in env.items(): + os.environ.setdefault(k, v) + return env + + +ENV = load_env() + +# Источники читают настройки при импорте — поэтому импорт после загрузки env. +from .bots import (BookBot, CamBot, DigestBot, HomeBot, InfraBot, MediaBot, # noqa: E402 + PhotoBot, SearchBot) +from .matrix import Matrix, poll_loop # noqa: E402 + +BOT_CLASSES = { + "MEDIA": MediaBot, + "PHOTO": PhotoBot, + "BOOK": BookBot, + "HOME": HomeBot, + "INFRA": InfraBot, + "SEARCH": SearchBot, + "DIGEST": DigestBot, + "CAM": CamBot, +} + + +def send_greeting(bot): + bot.mx.send_chunked(bot.room_id, bot.help_text()) + + +def main(): + hs = os.environ.get("MATRIX_HS", "https://matrix.buryans.ru") + stop = threading.Event() + bots = [] + + for prefix, cls in BOT_CLASSES.items(): + token = ENV.get(f"{prefix}_TOKEN") + user = ENV.get(f"{prefix}_USER") + room = ENV.get(f"{prefix}_ROOM") + if not (token and user and room): + print(f"[{prefix}] пропуск: нет токена/комнаты", flush=True) + continue + try: + mx = Matrix(hs, user, token) + me = mx.whoami() + if "error" in me: + print(f"[{prefix}] токен не работает: {me['error']}", flush=True) + continue + mx.join(room) + bot = cls(mx, room) + except Exception as e: + print(f"[{prefix}] ошибка запуска: {e}", flush=True) + continue + bots.append(bot) + threading.Thread(target=poll_loop, args=(bot, stop, send_greeting), + name=f"bot-{prefix.lower()}", daemon=True).start() + print(f"[{prefix}] запущен: {user} → {room}", flush=True) + + if not bots: + print("ни один бот не запустился", flush=True) + return 1 + + print(f"готово: {len(bots)} ботов слушают комнаты", flush=True) + + def shutdown(*_): + stop.set() + + signal.signal(signal.SIGTERM, shutdown) + signal.signal(signal.SIGINT, shutdown) + while not stop.is_set(): + time.sleep(2) + return 0 + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/ops/bots/hub/matrix.py b/ops/bots/hub/matrix.py new file mode 100644 index 0000000..1f40659 --- /dev/null +++ b/ops/bots/hub/matrix.py @@ -0,0 +1,160 @@ +"""Минимальный клиент 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) + + +class Bot: + """Бот = учётка + комната + набор команд.""" + + name = "bot" + title = "Бот" + room_env = "ROOM" + + def __init__(self, mx, room_id): + self.mx = mx + self.room_id = room_id + 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("Команды пишутся в этой комнате. `!help` — эта подсказка.") + return "\n".join(lines) + + def dispatch(self, text): + text = text.strip() + if not text.startswith("!"): + return None + parts = text[1:].split(None, 1) + if not parts: + return None + cmd = parts[0].lower() + arg = parts[1] if len(parts) > 1 else "" + if cmd in ("help", "помощь", "?", "start"): + 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 poll_loop(bot, stop_event, on_ready=None): + """Длинный опрос: слушаем свою комнату и отвечаем на команды.""" + since = None + first = True + 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 + if on_ready: + on_ready(bot) + continue + rooms = resp.get("rooms", {}).get("join", {}) + for rid, data in rooms.items(): + if rid != bot.room_id: + continue + for ev in data.get("timeline", {}).get("events", []): + if ev.get("type") != "m.room.message": + continue + if ev.get("sender") == bot.mx.user_id: + continue + body = ev.get("content", {}).get("body", "") + if not body.startswith("!"): + continue + reply = bot.dispatch(body) + if reply: + bot.mx.set_typing(bot.room_id, False) + bot.mx.send_chunked(bot.room_id, reply) + except Exception: + time.sleep(5) diff --git a/ops/bots/hub/sources.py b/ops/bots/hub/sources.py new file mode 100644 index 0000000..7807081 --- /dev/null +++ b/ops/bots/hub/sources.py @@ -0,0 +1,259 @@ +"""Источники данных: каждый сервис за небольшим интерфейсом.""" +import os +import subprocess +import urllib.parse + +from . import util + + +class Cfg: + """Настройки из переменных окружения.""" + + def __init__(self): + self.homeserver = os.environ.get("MATRIX_HS", "https://matrix.buryans.ru") + self.jellyfin_url = os.environ.get("JELLYFIN_URL", "http://192.168.1.103:8096") + self.jellyfin_key = os.environ.get("JELLYFIN_KEY", "") + self.sonarr_url = os.environ.get("SONARR_URL", "http://192.168.1.117:8989") + self.sonarr_key = os.environ.get("SONARR_KEY", "") + self.radarr_url = os.environ.get("RADARR_URL", "http://192.168.1.118:7878") + self.radarr_key = os.environ.get("RADARR_KEY", "") + self.prowlarr_url = os.environ.get("PROWLARR_URL", "http://192.168.1.119:9696") + self.prowlarr_key = os.environ.get("PROWLARR_KEY", "") + self.seerr_url = os.environ.get("SEERR_URL", "http://192.168.1.121:5055") + self.seerr_key = os.environ.get("SEERR_KEY", "") + self.paperless_url = os.environ.get("PAPERLESS_URL", "http://192.168.1.105:8000") + self.paperless_token = os.environ.get("PAPERLESS_TOKEN", "") + self.linkding_url = os.environ.get("LINKDING_URL", "http://192.168.1.127:3000") + self.linkding_token = os.environ.get("LINKDING_TOKEN", "") + self.immich_url = os.environ.get("IMMICH_URL", "http://192.168.1.104:2283") + self.immich_key = os.environ.get("IMMICH_KEY", "") + self.home_url = os.environ.get("HOME_URL", "http://192.168.1.106:8123") + self.home_token = os.environ.get("HOME_TOKEN", "") + self.prometheus_url = os.environ.get("PROMETHEUS_URL", "http://192.168.1.134:9090") + self.navidrome_db = os.environ.get("NAVIDROME_DB", "") + self.calibre_db = os.environ.get("CALIBRE_DB", "") + self.frigate_url = os.environ.get("FRIGATE_URL", "") + self.plex_url = os.environ.get("PLEX_URL", "http://192.168.1.116:32400") + self.plex_token = os.environ.get("PLEX_TOKEN", "") + + +CFG = Cfg() + + +# ─────────────────────────── МЕДИА ─────────────────────────── + +class Jellyfin: + def _hdr(self): + return {"Authorization": f'MediaBrowser Token="{CFG.jellyfin_key}"'} + + def info(self): + return util.get(f"{CFG.jellyfin_url}/System/Info", self._hdr(), ttl=300) + + def counts(self): + data, err = util.get(f"{CFG.jellyfin_url}/Items/Counts", self._hdr(), ttl=300) + if err: + return {} + return { + "Movie": data.get("MovieCount", 0), + "Series": data.get("SeriesCount", 0), + "Episode": data.get("EpisodeCount", 0), + "Audio": data.get("SongCount", 0), + "MusicAlbum": data.get("AlbumCount", 0), + } + + def recent(self, limit=10): + data, err = util.get( + f"{CFG.jellyfin_url}/Items?Recursive=true&IncludeItemTypes=Movie,Series&SortBy=DateCreated" + f"&SortOrder=Descending&Limit={limit}&Fields=ProductionYear,DateCreated", + self._hdr(), ttl=60) + if err: + return [], err + return (data or {}).get("Items", []), None + + def search(self, term, limit=8): + q = urllib.parse.quote(term) + data, err = util.get( + f"{CFG.jellyfin_url}/Items?SearchTerm={q}&Recursive=true&Limit={limit}" + f"&IncludeItemTypes=Movie,Series,Audio&Fields=ProductionYear", + self._hdr(), ttl=60) + if err: + return [], err + return (data or {}).get("Items", []), None + + def sessions(self): + data, err = util.get(f"{CFG.jellyfin_url}/Sessions", self._hdr(), ttl=10) + if err: + return [], err + return [s for s in (data or []) if s.get("NowPlayingItem")], None + + +class Arr: + def __init__(self, base, key, name): + self.base, self.key, self.name = base, key, name + + def _hdr(self): + return {"X-Api-Key": self.key} + + def status(self): + return util.get(f"{self.base}/api/v3/system/status", self._hdr(), ttl=60) + + def queue(self): + data, err = util.get(f"{self.base}/api/v3/queue?pageSize=50", self._hdr(), ttl=20) + if err: + return None, err + return (data or {}).get("totalRecords", 0), None + + def wanted(self): + data, err = util.get(f"{self.base}/api/v3/wanted/missing?pageSize=1", self._hdr(), ttl=120) + if err: + return None, err + return (data or {}).get("totalRecords", 0), None + + def diskspace(self): + data, err = util.get(f"{self.base}/api/v3/diskspace", self._hdr(), ttl=120) + if err: + return [], err + return data or [], None + + +class Sonarr(Arr): + def series(self): + data, err = util.get(f"{self.base}/api/v3/series", self._hdr(), ttl=180) + return (data or []), err + + +class Radarr(Arr): + def movies(self): + data, err = util.get(f"{self.base}/api/v3/movie", self._hdr(), ttl=180) + return (data or []), err + + +class Seerr: + def _hdr(self): + return {"X-Api-Key": CFG.seerr_key} + + def counts(self): + data, err = util.get(f"{CFG.seerr_url}/api/v1/request/count", self._hdr(), ttl=30) + if err: + return None, err + return data, None + + def requests(self, take=5): + data, err = util.get(f"{CFG.seerr_url}/api/v1/request?take={take}&filter=all&sort=added", self._hdr(), ttl=30) + if err: + return [], err + return (data or {}).get("results", []), None + + +class Navidrome: + """Navidrome без пароля: читаем базу напрямую (только чтение).""" + + def _q(self, sql): + if not CFG.navidrome_db: + return None, "нет доступа к базе Navidrome" + try: + out = subprocess.run( + ["ssh", "-o", "BatchMode=yes", "-o", "StrictHostKeyChecking=no", "root@192.168.1.10", + f"pct exec 125 -- docker exec navidrome sh -c {chr(34)}sqlite3 /data/navidrome.db \"{sql}\"{chr(34)}"], + capture_output=True, text=True, timeout=25) + if out.returncode != 0: + return None, out.stderr.strip()[:120] + return out.stdout.strip(), None + except Exception as e: + return None, str(e)[:120] + + def counts(self): + rows, err = self._q("select (select count(*) from artist), (select count(*) from album), (select count(*) from media_file)") + if err: + return None, err + try: + a, al, m = rows.split("|") + return {"artists": int(a), "albums": int(al), "tracks": int(m)}, None + except Exception: + return None, f"странный ответ: {rows[:80]}" + + +class Books: + """Calibre: читаем метаданные библиотеки.""" + + def _q(self, sql): + if not CFG.calibre_db: + return None, "нет доступа к базе Calibre" + try: + out = subprocess.run( + ["ssh", "-o", "BatchMode=yes", "-o", "StrictHostKeyChecking=no", "root@192.168.1.10", + f"pct exec 111 -- docker exec calibre-web sh -c {chr(34)}sqlite3 {CFG.calibre_db} \"{sql}\"{chr(34)}"], + capture_output=True, text=True, timeout=25) + if out.returncode != 0: + return None, out.stderr.strip()[:120] + return out.stdout.strip(), None + except Exception as e: + return None, str(e)[:120] + + def counts(self): + rows, err = self._q("select count(*) from books") + if err: + return None, err + return {"books": int(rows or 0)}, None + + +class Immich: + def _hdr(self): + return {"x-api-key": CFG.immich_key} + + def about(self): + return util.get(f"{CFG.immich_url}/api/server/about", self._hdr(), ttl=120) + + def stats(self): + return util.get(f"{CFG.immich_url}/api/server/storage", self._hdr(), ttl=120) + + +class Paperless: + def _hdr(self): + return {"Authorization": f"Token {CFG.paperless_token}"} + + def counts(self): + data, err = util.get(f"{CFG.paperless_url}/api/documents/?page_size=1", self._hdr(), ttl=120) + if err: + return None, err + return {"documents": (data or {}).get("count", 0)}, None + + +class Home: + def _hdr(self): + return {"Authorization": f"Bearer {CFG.home_token}"} + + def states(self): + data, err = util.get(f"{CFG.home_url}/api/states", self._hdr(), ttl=30) + return (data or []), err + + def config(self): + return util.get(f"{CFG.home_url}/api/config", self._hdr(), ttl=300) + + +class Prom: + def query(self, q): + data, err = util.get(f"{CFG.prometheus_url}/api/v1/query?query={q}", {}, ttl=15) + if err: + return None, err + try: + res = data["data"]["result"] + return (float(res[0]["value"][1]) if res else 0.0), None + except Exception: + return None, "неожиданный ответ" + + def targets(self): + data, err = util.get(f"{CFG.prometheus_url}/api/v1/targets?state=active", {}, ttl=20) + if err: + return [], err + return data.get("data", {}).get("activeTargets", []), None + + def alerts(self): + data, err = util.get(f"{CFG.prometheus_url}/api/v1/alerts", {}, ttl=20) + if err: + return [], err + return data.get("data", {}).get("alerts", []), None + + +SONARR = Sonarr(CFG.sonarr_url, CFG.sonarr_key, "Sonarr") +RADARR = Radarr(CFG.radarr_url, CFG.radarr_key, "Radarr") diff --git a/ops/bots/hub/util.py b/ops/bots/hub/util.py new file mode 100644 index 0000000..4b74a1e --- /dev/null +++ b/ops/bots/hub/util.py @@ -0,0 +1,88 @@ +"""Общие утилиты: HTTP с кэшем и разбор ответов.""" +import json +import time +import urllib.error +import urllib.parse +import urllib.request + +from urllib.parse import quote # noqa: F401 (имя используется ботами) + +_CACHE = {} +TTL_DEFAULT = 120 + + +def get(url, headers=None, ttl=TTL_DEFAULT, timeout=12): + """GET с кэшем на ttl секунд. Возвращает (данные|None, ошибка|None).""" + key = url + now = time.time() + if key in _CACHE and now - _CACHE[key][0] < ttl: + return _CACHE[key][1], _CACHE[key][2] + req = urllib.request.Request(url, headers=headers or {}) + try: + with urllib.request.urlopen(req, timeout=timeout) as r: + raw = r.read() + try: + data = json.loads(raw) + except json.JSONDecodeError: + data = raw.decode("utf-8", "replace") + _CACHE[key] = (now, data, None) + return data, None + except urllib.error.HTTPError as e: + body = "" + try: + body = e.read().decode("utf-8", "replace")[:200] + except Exception: + pass + _CACHE[key] = (now, None, f"HTTP {e.code} {body}") + return None, f"HTTP {e.code} {body}" + except Exception as e: + _CACHE[key] = (now, None, str(e)[:120]) + return None, str(e)[:120] + + +def post(url, payload=None, headers=None, form=False, timeout=15): + hdrs = dict(headers or {}) + if form: + body = urllib.parse.urlencode(payload or {}).encode() + hdrs["Content-Type"] = "application/x-www-form-urlencoded" + else: + body = json.dumps(payload or {}).encode() + hdrs.setdefault("Content-Type", "application/json") + req = urllib.request.Request(url, data=body, headers=hdrs, method="POST") + try: + with urllib.request.urlopen(req, timeout=timeout) as r: + raw = r.read() + try: + return json.loads(raw), None + except json.JSONDecodeError: + return raw.decode("utf-8", "replace"), None + except urllib.error.HTTPError as e: + return None, f"HTTP {e.code} {e.read().decode('utf-8', 'replace')[:160]}" + except Exception as e: + return None, str(e)[:120] + + +def human_bytes(n): + try: + n = float(n) + except (TypeError, ValueError): + return "—" + for unit in ("Б", "КБ", "МБ", "ГБ", "ТБ"): + if abs(n) < 1024: + return f"{n:.1f} {unit}" + n /= 1024 + return f"{n:.1f} ПБ" + + +def human_time(seconds): + try: + s = int(float(seconds)) + except (TypeError, ValueError): + return "—" + if s < 60: + return f"{s} с" + if s < 3600: + return f"{s // 60} мин" + if s < 86400: + return f"{s // 3600} ч {s % 3600 // 60} мин" + return f"{s // 86400} дн {s % 86400 // 3600} ч" diff --git a/ops/bots/selftest.py b/ops/bots/selftest.py new file mode 100644 index 0000000..7c59734 --- /dev/null +++ b/ops/bots/selftest.py @@ -0,0 +1,47 @@ +#!/usr/bin/env python3 +"""Проверка источников данных и ответов ботов без Matrix.""" +import os +import sys + +sys.path.insert(0, "/opt/hub-bots") + +from hub.main import ENV # загружает настройки +from hub.bots import (BookBot, CamBot, DigestBot, HomeBot, InfraBot, MediaBot, + PhotoBot, SearchBot) + + +class FakeMX: + user_id = "@test:local" + + def send_chunked(self, *a, **k): + return {} + + def send(self, *a, **k): + return {} + + def set_typing(self, *a, **k): + return {} + + +def check(name, fn): + try: + out = fn() + except Exception as e: + out = f"ИСКЛЮЧЕНИЕ: {type(e).__name__}: {e}" + print(f"\n══════ {name} ══════") + print(out if out else "(пусто)") + return out + + +mx = FakeMX() +check("media !stats", lambda: MediaBot(mx, "!r").dispatch("!stats")) +check("media !new", lambda: MediaBot(mx, "!r").dispatch("!new")) +check("media !queue", lambda: MediaBot(mx, "!r").dispatch("!queue")) +check("media !disk", lambda: MediaBot(mx, "!r").dispatch("!disk")) +check("book !stats", lambda: BookBot(mx, "!r").dispatch("!stats")) +check("photo !stats", lambda: PhotoBot(mx, "!r").dispatch("!stats")) +check("home !stats", lambda: HomeBot(mx, "!r").dispatch("!stats")) +check("infra !status", lambda: InfraBot(mx, "!r").dispatch("!status")) +check("digest !digest", lambda: DigestBot(mx, "!r").dispatch("!digest")) +check("cam !status", lambda: CamBot(mx, "!r").dispatch("!status")) +check("search !s", lambda: SearchBot(mx, "!r").dispatch("!s матрица")) diff --git a/ops/secrets-enc/hub-bots-secrets.age b/ops/secrets-enc/hub-bots-secrets.age new file mode 100644 index 0000000..7f91f43 --- /dev/null +++ b/ops/secrets-enc/hub-bots-secrets.age @@ -0,0 +1,14 @@ +{ + "data": "ENC[AES256_GCM,data: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,iv:A69BlmTsEmBr1Tv0d5MkhczS3rvn8R7KgdW7DCBIMI0=,tag:8FzjyDWLDIjOpvzyBxuQcA==,type:str]", + "sops": { + "age": [ + { + "enc": "-----BEGIN AGE ENCRYPTED FILE-----\nYWdlLWVuY3J5cHRpb24ub3JnL3YxCi0+IFgyNTUxOSBRSWhnbEdlekhHOWlzUzBj\nNGZ6Q2xPY1FuSVRYMDZtaHpDaW5nbHQvSlI4CnBBakgza3hGSlNmN3ZuazNVVkxi\nWjFhRXJjejFETG9PVG1RdzNxc05NUmMKLS0tIHlnczJmb2FUZVByeUtkd0I1Tmor\nV0NtemIvek1tYXpzQWNiYmVCcE82MFUKSHcrd297ov8aPVemaYzjuAislF7Omk4Y\n5ppiioi/VhypCRqgROEzy3vpPpZctrdOfwejbUNRvAuExF4VOL+mig==\n-----END AGE ENCRYPTED FILE-----\n", + "recipient": "age197n2mdprtp43fshumeph2gmllhwudsegh7pqsynkgxwf67gd94zqhnsedp" + } + ], + "lastmodified": "2026-10-19T13:37:13Z", + "mac": "ENC[AES256_GCM,data:z/pA2FwY0oJJyY9HxHL1r3jrABiGy/OVHtSULgou+xQpQ5cvOapsTyYK900lgRjnYDwgQVlE9CmEm66j2Ek+Ddy/qwYubFpUrS+cC28qPwSieKNHNQFt45p69Kr67NaS8i5KT1yougpmgLzVwA7+5OkdeMqGo1qWvtF7pztszB0=,iv:E8quesZ/B+WZMqKb5EC5h3MveaHkV+o7HO8YSYJzRsI=,tag:8EUEWUmXh3juK1CPwmKVZg==,type:str]", + "version": "3.13.3" + } +}