init

.env.example

@@ -0,0 +1,12 @@
+MAX_TOKEN=eyJhbGci...
+MAX_DEVICE_ID=a1b2c3d4-e5f6-7890-abcd-ef1234567890
+TG_BOT_TOKEN=123456:ABC-DEF1234...
+TG_FORUM_CHANNEL_ID=-1001234567890
+FALLBACK_USER_ID=987654321
+DATABASE_URL=sqlite+aiosqlite:///app/data/bridge.db
+REDIS_URL=redis://redis:6379/0
+TG_RATE_LIMIT_DELAY_SEC=3.5
+MAX_RATE_LIMIT_DELAY_SEC=1.0
+LS_TOPIC_PREFIX=👤 
+MAX_RECONNECT_FETCH_LIMIT=50
+LOG_LEVEL=INFO

.env.sample

@@ -1,8 +0,0 @@
-TZ=Europe/Moscow
-PYTHONUNBUFFERED=0
-MAX_PHONE=+10000000000
-MAX_WORK_DIR=cache
-TELEGRAM_BOT_TOKEN=123456789:your_bot_token
-TELEGRAM_FALLBACK_USER_ID=123456789
-## SQLite база (по умолчанию используется cache/max2telegram.db)
-SQLITE_PATH=cache/max2telegram.db

.gitignore

@@ -1,34 +1,9 @@
 .env
-cache/*
+data/
-
-# Python bytecode / cache
 __pycache__/
-*.py[cod]
+*.pyc
-*$py.class
-
-# Virtual environments
 .venv/
 venv/
-env/
+*.db
-ENV/
+*.db-wal
-
+*.db-shm
-# Build / packaging
-build/
-dist/
-*.egg-info/
-.eggs/
-pip-wheel-metadata/
-
-# Tool caches
-.pytest_cache/
-.mypy_cache/
-.ruff_cache/
-.coverage
-.coverage.*
-htmlcov/
-
-# IDE / OS
-.idea/
-.vscode/
-.DS_Store
-Thumbs.db

Dockerfile

@@ -2,11 +2,16 @@ FROM python:3.12-slim
 
 WORKDIR /app
 
-RUN apt-get update \
+RUN apt-get update && apt-get install -y --no-install-recommends \
-    && apt-get install -y --no-install-recommends git \
+    gcc \
     && rm -rf /var/lib/apt/lists/*
-COPY ./src/requirements.txt .
-RUN pip install --no-cache-dir -r ./requirements.txt
 
-COPY ./src .
+COPY requirements.txt .
-CMD [ "python", "-u", "./main.py" ]
+RUN pip install --no-cache-dir -r requirements.txt
+
+COPY app/ ./app/
+
+ENV PYTHONUNBUFFERED=1
+ENV PYTHONPATH=/app
+
+CMD ["python", "-m", "app.main"]

README.md

@@ -1,122 +1,48 @@
 # max2telegram
 
-Мост для пересылки сообщений из Max в Telegram.
+Асинхронный мост для двусторонней синхронизации переписки между мессенджером **MAX** и **Telegram** (форум-канал с топиками).
 
-## Что умеет
+## Архитектура
 
-- Слушает входящие сообщения в Max через `PyMax`.
+Приложение построено по слоям:
-- Пересылает в Telegram:
-  - текст;
-  - фото;
-  - видео.
-- Для нескольких вложений отправляет единым альбомом (`sendMediaGroup`).
-- В тексте указывает источник в формате: `MAX: <ник> / <название чата>`.
-- Защищает от дублей через SQLite (`forwarded_messages`).
 
-## Логика выбора чата в Telegram
+| Слой | Назначение |
+|------|------------|
+| `max_layer` | WebSocket-клиент MAX (PyMAX WebClient), listener и worker |
+| `telegram_layer` | Aiogram dispatcher, TG worker, admin-команды |
+| `router` | Маршрутизация по ID, дедупликация, постановка в очереди |
+| `queue` | Redis-очереди `max2tg_queue` и `tg2max_queue` |
+| `storage` | SQLite: маппинги, маркеры, связи сообщений |
 
-1. Берется название чата из Max.
+## Быстрый старт
-2. Если для этого Max-чата есть явная привязка (см. `/bind_max` ниже), сообщение отправляется в привязанный Telegram-чат.
-3. Иначе: если у бота найден Telegram-чат с таким же названием, сообщение отправляется туда.
-4. Если совпадения нет, сообщение уходит в личку на `TELEGRAM_FALLBACK_USER_ID`.
 
-## Важно про поиск чатов
+1. Скопируйте `.env.example` в `.env` и заполните переменные.
+2. Создайте папку `data/` (монтируется для SQLite и сессии PyMAX).
+3. Запустите:
 
-Поиск чатов по названию выполняется через `getUpdates`, поэтому:
+```bash
-
+docker compose up -d
-- бот должен быть добавлен в нужные Telegram-чаты;
+```
-- в этих чатах должен быть хотя бы один апдейт (сообщение/событие), чтобы чат появился в апдейтах;
-- если у бота включен privacy mode, он может не получать обычные сообщения из групп — тогда чат может не “обнаружиться” через `getUpdates`.
-
-### Привязка Max-чата к Telegram-чату (рекомендуется)
-
-Чтобы не зависеть от `getUpdates` и privacy mode, можно один раз “забиндить” нужный Telegram-чат на название чата в Max.
-
-В целевом Telegram-чате напиши команду:
-
-- `/bind_max <точное название чата в Max>`
-
-Пример:
-
-- `/bind_max Свободный микрофон`
-
-После этого пересылка **из Max в Telegram** для чата `Свободный микрофон` будет идти строго в этот Telegram-чат (привязка хранится в SQLite).
 
 ## Переменные окружения
 
-Используется файл `.env` в корне проекта.
+См. `tech-specs.md`, раздел 6, и `.env.example`.
 
-Пример смотри в `.env.sample`.
+## Команды (только FALLBACK_USER_ID в ЛС с ботом)
 
-Обязательные переменные:
+- `/start` — статус подключения
+- `/help` — справка
+- `/list` — список маппингов
+- `/join <ссылка>` — вступить в MAX-группу
+- `/leave <id или название>` — выйти из MAX-чата
+- `/last_messages <id или название>` — последние 10 сообщений
 
-- `MAX_PHONE` - номер телефона аккаунта Max;
+## Локальная разработка
-- `MAX_WORK_DIR` - директория сессии Max (обычно `cache`);
-- `TELEGRAM_BOT_TOKEN` - токен Telegram-бота;
-- `TELEGRAM_FALLBACK_USER_ID` - id пользователя Telegram для fallback отправки;
-- `SQLITE_PATH` - путь к SQLite базе (рекомендуется `cache/max2telegram.db`, по умолчанию так и будет).
 
-Дополнительно:
+```bash
+pip install -r requirements.txt
+export $(cat .env | xargs)   # Linux/macOS
+python -m app.main
+```
 
-- `TZ` - таймзона контейнера;
+Redis должен быть доступен по `REDIS_URL`.
-- `PYTHONUNBUFFERED` - режим буферизации вывода Python.
-
-## Быстрый старт (Docker)
-
-1. Скопировать шаблон:
-   - `copy .env.sample .env` (Windows)
-2. Заполнить `.env` своими значениями.
-3. Пройти аутентификацию Max (см. ниже).
-4. Запустить:
-   - `docker compose up -d --build`
-5. Логи:
-   - `docker compose logs -f`
-
-## Аутентификация Max
-
-Перед запуском приложения необходимо пройти аутентификацию Max, чтобы создать сессионный файл.
-
-### Локально (без Docker)
-
-1. Убедиться, что `.env` заполнен, особенно `MAX_PHONE`.
-2. Запустить скрипт аутентификации:
-   - `python auth.py`
-3. Следовать инструкциям в консоли (ввод кода подтверждения и т.д.).
-4. После успешной аутентификации сессионный файл сохранится в директории `MAX_WORK_DIR` (по умолчанию `cache`).
-
-### В Docker
-
-1. Запустить контейнер с интерактивной сессией:
-   - `docker compose run --rm max2telegram python auth.py`
-2. Следовать инструкциям в консоли.
-3. После завершения запустить основное приложение:
-   - `docker compose up -d`
-
-## Запуск локально (без Docker)
-
-1. Установить зависимости:
-   - `pip install -r src/requirements.txt`
-2. Создать `.env` на основе `.env.sample`.
-3. Пройти аутентификацию Max:
-   - `python auth.py`
-4. Запустить приложение:
-   - `python src/main.py`
-
-## Структура проекта
-
-- `auth.py` - скрипт аутентификации Max (создание сессии).
-- `src/main.py` - точка входа, инициализация клиентов.
-- `src/bridge.py` - основная логика маршрутизации и отправки.
-- `src/telegram_api.py` - Telegram Bot API клиент.
-- `src/max_parser.py` - разбор входящих сообщений Max.
-- `src/storage.py` - SQLite слой для дедупликации.
-- `src/config.py` - загрузка конфигурации из окружения.
-
-## Типичные проблемы
-
-- Фото/видео не приходят:
-  - проверь, что бот имеет доступ к целевому чату;
-  - проверь валидность URL вложений и токена бота.
-- Сообщения идут только в fallback:
-  - бот еще не видел апдейты из нужного чата;
-  - название чата в Max и Telegram не совпадает.

app/config.py

@@ -0,0 +1,35 @@
+from pathlib import Path
+
+from pydantic import model_validator
+from pydantic_settings import BaseSettings, SettingsConfigDict
+
+
+class Settings(BaseSettings):
+    model_config = SettingsConfigDict(env_file=".env", env_file_encoding="utf-8", extra="ignore")
+
+    max_token: str
+    max_device_id: str
+    tg_bot_token: str
+    tg_forum_channel_id: int
+    fallback_user_id: int
+    database_url: str = "sqlite+aiosqlite:///app/data/bridge.db"
+    redis_url: str = "redis://redis:6379/0"
+    tg_rate_limit_delay_sec: float = 3.5
+    max_rate_limit_delay_sec: float = 1.0
+    ls_topic_prefix: str = "👤 "
+    max_reconnect_fetch_limit: int = 50
+    log_level: str = "INFO"
+    data_dir: str = ""
+    max_session_name: str = "max_session.db"
+
+    @property
+    def sqlite_path(self) -> str:
+        if self.database_url.startswith("sqlite+aiosqlite:///"):
+            return self.database_url.removeprefix("sqlite+aiosqlite:///")
+        return "app/data/bridge.db"
+
+    @model_validator(mode="after")
+    def _default_data_dir(self) -> "Settings":
+        if not self.data_dir:
+            object.__setattr__(self, "data_dir", str(Path(self.sqlite_path).parent))
+        return self

app/logging_setup.py

@@ -0,0 +1,28 @@
+import logging
+import sys
+
+import structlog
+
+
+def setup_logging(level: str) -> None:
+  logging.basicConfig(
+    format="%(message)s",
+    stream=sys.stdout,
+    level=getattr(logging, level.upper(), logging.INFO),
+  )
+  structlog.configure(
+    processors=[
+      structlog.contextvars.merge_contextvars,
+      structlog.processors.add_log_level,
+      structlog.processors.TimeStamper(fmt="iso"),
+      structlog.processors.StackInfoRenderer(),
+      structlog.processors.format_exc_info,
+      structlog.processors.JSONRenderer(),
+    ],
+    wrapper_class=structlog.make_filtering_bound_logger(
+      getattr(logging, level.upper(), logging.INFO)
+    ),
+    context_class=dict,
+    logger_factory=structlog.PrintLoggerFactory(),
+    cache_logger_on_first_use=True,
+  )

app/main.py

@@ -0,0 +1,93 @@
+import asyncio
+from collections.abc import Awaitable, Callable
+from pathlib import Path
+
+import structlog
+
+from app.config import Settings
+from app.logging_setup import setup_logging
+from app.max_layer.client_holder import MaxClientHolder
+from app.max_layer.listener import MaxListener
+from app.max_layer.worker import MaxWorker
+from app.queue.redis_queue import RedisQueue
+from app.router.router import MessageRouter
+from app.storage.database import create_engine, create_session_factory
+from app.storage.repository import SqliteStorage
+from app.telegram_layer.bot_holder import BotHolder
+from app.telegram_layer.listener import TelegramListener
+from app.telegram_layer.worker import TelegramWorker
+from app.topic_locks import TopicLockRegistry
+
+logger = structlog.get_logger(__name__)
+
+SERVICE_RESTART_DELAY_SEC = 3.0
+
+
+async def run_service(
+  name: str,
+  runner: Callable[[], Awaitable[None]],
+) -> None:
+  while True:
+    try:
+      await runner()
+      logger.warning("service_stopped", service=name)
+    except asyncio.CancelledError:
+      logger.info("service_cancelled", service=name)
+      raise
+    except Exception:
+      logger.exception("service_failed", service=name)
+    await asyncio.sleep(SERVICE_RESTART_DELAY_SEC)
+
+
+async def main() -> None:
+  settings = Settings()
+  setup_logging(settings.log_level)
+  Path(settings.sqlite_path).parent.mkdir(parents=True, exist_ok=True)
+  Path(settings.data_dir).mkdir(parents=True, exist_ok=True)
+
+  engine = create_engine(settings.database_url)
+  session_factory = create_session_factory(engine)
+  storage = SqliteStorage(session_factory)
+  await storage.init()
+  mappings = await storage.list_mappings()
+  logger.info(
+    "storage_ready",
+    sqlite_path=settings.sqlite_path,
+    mapping_count=len(mappings),
+  )
+
+  queue = RedisQueue(settings.redis_url)
+  await queue.connect()
+
+  topic_locks = TopicLockRegistry()
+  router = MessageRouter(
+    storage=storage,
+    queue=queue,
+    forum_channel_id=settings.tg_forum_channel_id,
+    topic_locks=topic_locks,
+  )
+
+  max_holder = MaxClientHolder()
+  bot_holder = BotHolder()
+
+  max_listener = MaxListener(settings, max_holder, router, storage)
+  tg_listener = TelegramListener(
+    settings, bot_holder, router, storage, max_holder
+  )
+  tg_worker = TelegramWorker(
+    settings, bot_holder, max_holder, queue, storage, topic_locks
+  )
+  max_worker = MaxWorker(settings, max_holder, bot_holder, queue, router, storage)
+
+  logger.info("max2telegram_starting")
+
+  await asyncio.gather(
+    run_service("max_listener", max_listener.run),
+    run_service("tg_listener", tg_listener.run),
+    run_service("tg_worker", tg_worker.run),
+    run_service("max_worker", max_worker.run),
+  )
+
+
+if __name__ == "__main__":
+  asyncio.run(main())

app/max_layer/client_holder.py

@@ -0,0 +1,22 @@
+import asyncio
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+  from pymax import WebClient
+
+
+class MaxClientHolder:
+  def __init__(self) -> None:
+    self.client: WebClient | None = None
+    self.ready = asyncio.Event()
+    self.my_user_id: int | None = None
+
+  def set_client(self, client: "WebClient", my_user_id: int | None) -> None:
+    self.client = client
+    self.my_user_id = my_user_id
+    self.ready.set()
+
+  async def wait_client(self) -> "WebClient":
+    await self.ready.wait()
+    assert self.client is not None
+    return self.client

app/max_layer/formatter.py

@@ -0,0 +1,223 @@
+from typing import Any
+
+import structlog
+from pymax.types.domain.message import Message as MaxMessage
+
+from app.models.domain import MaxIncomingMessage
+
+logger = structlog.get_logger(__name__)
+
+def get_forward_link(message: MaxMessage) -> dict[str, Any] | None:
+  link = getattr(message, "link", None)
+  if not isinstance(link, dict):
+    return None
+  if str(link.get("type", "")).upper() != "FORWARD":
+    return None
+  return link
+
+
+def extract_forwarded_content(
+  message: MaxMessage,
+) -> tuple[str, list[dict[str, Any]]] | None:
+  link = get_forward_link(message)
+  if link is None:
+    return None
+
+  nested = link.get("message")
+  if not isinstance(nested, dict):
+    logger.warning(
+      "max_forward_missing_nested_message",
+      chat_id=message.chat_id,
+      message_id=message.id,
+    )
+    return None
+
+  text = nested.get("text") or ""
+  attaches = nested.get("attaches") or []
+  if not isinstance(attaches, list):
+    attaches = []
+
+  logger.info(
+    "max_forward_extracted",
+    chat_id=message.chat_id,
+    message_id=message.id,
+    nested_message_id=nested.get("id"),
+    nested_sender=nested.get("sender"),
+    text_len=len(text),
+    attach_count=len(attaches),
+  )
+  return text, attaches
+
+
+def format_forwarded_text(
+  original_text: str,
+  original_sender_name: str | None = None,
+) -> str:
+  header = "↪️ Переслано"
+  if original_sender_name:
+    header += f" от {original_sender_name}"
+  if original_text:
+    return f"{header}:\n{original_text}"
+  return header
+
+
+def _attach_type(attach: dict[str, Any]) -> str:
+  return str(attach.get("_type") or attach.get("type") or "").upper()
+
+
+async def resolve_raw_attaches(
+  client,
+  chat_id: int,
+  message_id: int,
+  attaches: list[dict[str, Any]],
+) -> list[dict]:
+  items: list[dict] = []
+  for attach in attaches:
+    if not isinstance(attach, dict):
+      continue
+
+    attach_type = _attach_type(attach)
+    if attach_type == "PHOTO":
+      url = attach.get("baseUrl") or attach.get("base_url")
+      if url:
+        items.append(
+          {
+            "kind": "photo",
+            "url": url,
+            "max_chat_id": chat_id,
+            "max_message_id": message_id,
+          }
+        )
+      continue
+
+    if attach_type == "VIDEO":
+      video_id = attach.get("videoId") or attach.get("video_id")
+      if video_id is not None:
+        items.append(
+          {
+            "kind": "video",
+            "max_chat_id": chat_id,
+            "max_message_id": message_id,
+            "max_video_id": video_id,
+          }
+        )
+      continue
+
+    if attach_type == "FILE":
+      file_id = attach.get("fileId") or attach.get("file_id")
+      if file_id is not None:
+        items.append(
+          {
+            "kind": "document",
+            "file_name": attach.get("name"),
+            "max_chat_id": chat_id,
+            "max_message_id": message_id,
+            "max_file_id": file_id,
+          }
+        )
+      continue
+
+    url = attach.get("baseUrl") or attach.get("base_url") or attach.get("url")
+    if url:
+      items.append(
+        {
+          "kind": "document",
+          "url": url,
+          "max_chat_id": chat_id,
+          "max_message_id": message_id,
+        }
+      )
+
+  logger.debug(
+    "max_raw_attaches_resolved",
+    chat_id=chat_id,
+    message_id=message_id,
+    input_count=len(attaches),
+    resolved_count=len(items),
+  )
+  return items
+
+
+async def resolve_media(client, message: MaxMessage) -> list[dict]:
+  from pymax.types.domain.attachments.file import FileAttachment
+  from pymax.types.domain.attachments.photo import PhotoAttachment
+  from pymax.types.domain.attachments.video import VideoAttachment
+
+  items: list[dict] = []
+  chat_id = message.chat_id
+  if chat_id is None:
+    return items
+
+  for attach in message.attaches:
+    if isinstance(attach, dict):
+      items.extend(
+        await resolve_raw_attaches(client, chat_id, message.id, [attach])
+      )
+      continue
+    if isinstance(attach, PhotoAttachment):
+      items.append(
+        {
+          "kind": "photo",
+          "url": attach.base_url,
+          "max_chat_id": chat_id,
+          "max_message_id": message.id,
+        }
+      )
+    elif isinstance(attach, VideoAttachment):
+      items.append(
+        {
+          "kind": "video",
+          "max_chat_id": chat_id,
+          "max_message_id": message.id,
+          "max_video_id": attach.video_id,
+        }
+      )
+    elif isinstance(attach, FileAttachment):
+      items.append(
+        {
+          "kind": "document",
+          "file_name": attach.name,
+          "max_chat_id": chat_id,
+          "max_message_id": message.id,
+          "max_file_id": attach.file_id,
+        }
+      )
+    else:
+      url = getattr(attach, "base_url", None) or getattr(attach, "url", None)
+      if url:
+        items.append(
+          {
+            "kind": "document",
+            "url": url,
+            "max_chat_id": chat_id,
+            "max_message_id": message.id,
+          }
+        )
+  return items
+
+
+def build_chat_title(chat, ls_prefix: str) -> tuple[str, bool]:
+  is_dm = bool(getattr(chat, "is_dialog", False) or chat.type == "DIALOG")
+  if is_dm:
+    title = chat.title or "Контакт"
+    if not title.startswith(ls_prefix.strip()):
+      title = f"{ls_prefix}{title}"
+    return title, True
+  return chat.title or f"Чат {chat.id}", False
+
+
+def resolve_sender_name(user) -> str:
+  if user is None:
+    return "Неизвестный"
+  if user.names:
+    name = user.names[0]
+    parts = [name.first_name, name.last_name]
+    return " ".join(p for p in parts if p) or f"User {user.id}"
+  return f"User {user.id}"
+
+
+def format_max_text(message: MaxIncomingMessage) -> str:
+  if message.is_dm:
+    return message.text
+  sender = message.sender_name or "Неизвестный"
+  return f"{sender}:\n{message.text}"

app/max_layer/listener.py

@@ -0,0 +1,241 @@
+import asyncio
+from pathlib import Path
+
+import structlog
+from pymax import ExtraConfig, Message, WebClient
+from pymax.types.domain.enums import ChatType
+
+from app.config import Settings
+from app.media_transfer import download_max_media, tmp_dir
+from app.max_layer.client_holder import MaxClientHolder
+from app.max_layer.formatter import (
+  build_chat_title,
+  extract_forwarded_content,
+  format_forwarded_text,
+  resolve_media,
+  resolve_raw_attaches,
+  resolve_sender_name,
+)
+from app.models.domain import MaxIncomingMessage
+from app.router.router import MessageRouter
+from app.storage.protocols import StoragePort
+
+logger = structlog.get_logger(__name__)
+
+
+class MaxListener:
+  def __init__(
+    self,
+    settings: Settings,
+    holder: MaxClientHolder,
+    router: MessageRouter,
+    storage: StoragePort,
+  ) -> None:
+    self._settings = settings
+    self._holder = holder
+    self._router = router
+    self._storage = storage
+    self._client: WebClient | None = None
+    self._tmp_dir = tmp_dir(self._settings.data_dir)
+
+  def build_client(self) -> WebClient:
+    work_dir = str(Path(self._settings.data_dir))
+    extra = ExtraConfig(
+      token=self._settings.max_token,
+      device_id=self._settings.max_device_id,
+      log_level=self._settings.log_level,
+      reconnect=True,
+      reconnect_delay=3.0,
+      telemetry=False,
+    )
+    client = WebClient(
+      session_name=self._settings.max_session_name,
+      work_dir=work_dir,
+      extra_config=extra,
+    )
+    self._register_handlers(client)
+    return client
+
+  def _register_handlers(self, client: WebClient) -> None:
+    @client.on_start()
+    async def on_start(c: WebClient) -> None:
+      my_id = c.me.contact.id if c.me else None
+      self._holder.set_client(c, my_id)
+      logger.info("max_client_started", user_id=my_id)
+      await self._catch_up_history(c)
+
+    @client.on_message()
+    async def on_message(message: Message, c: WebClient) -> None:
+      logger.debug(
+        "max_message_event",
+        chat_id=message.chat_id,
+        message_id=message.id,
+        sender=message.sender,
+        msg_type=message.type,
+        has_text=bool(message.text),
+        attach_count=len(message.attaches),
+        is_forward=bool(getattr(message, "link", None)),
+      )
+      try:
+        await self._process_message(c, message)
+      except Exception:
+        logger.exception(
+          "max_message_handler_failed",
+          chat_id=message.chat_id,
+          message_id=message.id,
+        )
+
+  async def run(self) -> None:
+    self._client = self.build_client()
+    await self._client.start()
+
+  async def _catch_up_history(self, client: WebClient) -> None:
+    if not client.chats:
+      logger.info("max_history_catch_up_skipped", reason="no_chats")
+      return
+    limit = self._settings.max_reconnect_fetch_limit
+    logger.info("max_history_catch_up_started", chat_count=len(client.chats), limit=limit)
+    for chat in client.chats:
+      try:
+        messages = await client.fetch_history(chat_id=chat.id, backward=limit)
+        if not messages:
+          logger.debug("max_history_empty", chat_id=chat.id)
+          continue
+        logger.info("max_history_fetched", chat_id=chat.id, count=len(messages))
+        for msg in sorted(messages, key=lambda m: m.id):
+          await self._process_message(client, msg)
+      except Exception:
+        logger.exception("max_history_fetch_failed", chat_id=chat.id)
+
+  async def _process_message(self, client: WebClient, message: Message) -> None:
+    if message.chat_id is None:
+      logger.debug("max_message_skipped", reason="no_chat_id", message_id=message.id)
+      return
+    if self._holder.my_user_id and message.sender == self._holder.my_user_id:
+      link = await self._storage.get_tg_message_by_max(
+        message.chat_id, message.id
+      )
+      if link is not None:
+        logger.debug(
+          "max_message_skipped",
+          reason="own_echo",
+          chat_id=message.chat_id,
+          message_id=message.id,
+        )
+        return
+
+    forwarded = extract_forwarded_content(message)
+    effective_text = message.text or ""
+    forwarded_attaches: list | None = None
+    if forwarded is not None:
+      nested_text, nested_attaches = forwarded
+      original_sender_name: str | None = None
+      nested = getattr(message, "link", {}).get("message", {})
+      nested_sender = nested.get("sender") if isinstance(nested, dict) else None
+      if nested_sender:
+        try:
+          user = await client.get_user(nested_sender)
+          original_sender_name = resolve_sender_name(user)
+        except Exception:
+          original_sender_name = f"User {nested_sender}"
+          logger.warning(
+            "max_forward_sender_lookup_failed",
+            chat_id=message.chat_id,
+            message_id=message.id,
+            nested_sender=nested_sender,
+          )
+      effective_text = format_forwarded_text(nested_text, original_sender_name)
+      forwarded_attaches = nested_attaches
+
+    has_content = bool(
+      effective_text.strip()
+      or message.attaches
+      or forwarded_attaches
+    )
+    if not has_content:
+      logger.debug(
+        "max_message_skipped",
+        reason="empty",
+        chat_id=message.chat_id,
+        message_id=message.id,
+        is_forward=forwarded is not None,
+      )
+      return
+
+    try:
+      chat = await client.get_chat(message.chat_id)
+    except Exception:
+      logger.exception("max_chat_fetch_failed", chat_id=message.chat_id)
+      return
+
+    is_dm = chat.type == ChatType.DIALOG or getattr(chat, "is_dialog", False)
+    chat_title, _ = build_chat_title(chat, self._settings.ls_topic_prefix)
+
+    sender_name: str | None = None
+    if not is_dm and message.sender:
+      try:
+        user = await client.get_user(message.sender)
+        sender_name = resolve_sender_name(user)
+      except Exception:
+        sender_name = f"User {message.sender}"
+
+    reply_to: int | None = None
+    if message.options and isinstance(message.options, dict):
+      reply_to = message.options.get("replyTo")
+    if reply_to is None and message.prev_message_id:
+      try:
+        reply_to = int(message.prev_message_id)
+      except (TypeError, ValueError):
+        reply_to = None
+
+    try:
+      if forwarded_attaches is not None:
+        # File API requires the forward wrapper message id in this chat,
+        # not the nested original message id (error.user.file.access).
+        media = await resolve_raw_attaches(
+          client, message.chat_id, message.id, forwarded_attaches
+        )
+      else:
+        media = await resolve_media(client, message)
+      media = await download_max_media(client, media, self._tmp_dir)
+    except Exception:
+      logger.exception(
+        "max_media_resolve_failed",
+        chat_id=message.chat_id,
+        message_id=message.id,
+      )
+      media = []
+
+    logger.info(
+      "max_message_processing",
+      chat_id=message.chat_id,
+      message_id=message.id,
+      is_forward=forwarded is not None,
+      text_len=len(effective_text),
+      media_count=len(media),
+      is_dm=is_dm,
+    )
+
+    incoming = MaxIncomingMessage(
+      max_chat_id=message.chat_id,
+      max_message_id=message.id,
+      text=effective_text,
+      sender_id=message.sender,
+      sender_name=sender_name,
+      is_dm=is_dm,
+      chat_title=chat_title,
+      reply_to_max_message_id=reply_to,
+      media=media,
+    )
+    try:
+      await self._router.handle_max_message(incoming)
+    except Exception:
+      logger.exception(
+        "max_route_failed",
+        chat_id=message.chat_id,
+        message_id=message.id,
+      )
+      await self._router.notify_error(
+        "Ошибка маршрутизации MAX → TG",
+        f"chat_id={message.chat_id} message_id={message.id}",
+      )

app/max_layer/worker.py

@@ -0,0 +1,128 @@
+import asyncio
+
+import aiohttp
+import structlog
+from pymax import File, Photo, Video
+
+from app.config import Settings
+from app.media_transfer import download_media_item, tmp_dir
+from app.max_layer.client_holder import MaxClientHolder
+from app.models.tasks import SetReactionTask, Tg2MaxTask
+from app.queue.protocols import QueuePort
+from app.router.router import MessageRouter
+from app.storage.protocols import StoragePort
+from app.telegram_layer.bot_holder import BotHolder
+
+logger = structlog.get_logger(__name__)
+
+
+class MaxWorker:
+  def __init__(
+    self,
+    settings: Settings,
+    holder: MaxClientHolder,
+    bot_holder: BotHolder,
+    queue: QueuePort,
+    router: MessageRouter,
+    storage: StoragePort,
+  ) -> None:
+    self._settings = settings
+    self._holder = holder
+    self._bot_holder = bot_holder
+    self._queue = queue
+    self._router = router
+    self._storage = storage
+    self._running = True
+    self._tmp_dir = tmp_dir(self._settings.data_dir)
+
+  async def run(self) -> None:
+    logger.info("max_worker_started")
+    while self._running:
+      task = await self._queue.dequeue_tg2max(timeout=5)
+      if task is None:
+        continue
+      logger.info(
+        "max_worker_task_received",
+        tg_message_id=task.tg_message_id,
+        max_chat_id=task.max_chat_id,
+        media_count=len(task.media),
+      )
+      try:
+        await self._process(task)
+      except Exception as exc:
+        logger.exception("max_worker_failed", tg_message_id=task.tg_message_id)
+        await self._router.notify_error(
+          "Ошибка отправки в MAX",
+          f"tg_message_id={task.tg_message_id}: {exc}",
+        )
+      await asyncio.sleep(self._settings.max_rate_limit_delay_sec)
+
+  async def _process(self, task: Tg2MaxTask) -> None:
+    client = await self._holder.wait_client()
+    attachments = await self._build_attachments(task.media)
+    logger.debug(
+      "max_worker_sending",
+      max_chat_id=task.max_chat_id,
+      attachment_count=len(attachments),
+      text_len=len(task.text),
+      reply_to=task.reply_to_max_message_id,
+    )
+
+    sent = await client.send_message(
+      chat_id=task.max_chat_id,
+      text=task.text,
+      reply_to=task.reply_to_max_message_id,
+      attachments=attachments or None,
+    )
+    if sent is None:
+      raise RuntimeError("MAX API returned no message")
+
+    await self._storage.save_message_link(
+      task.max_chat_id,
+      sent.id,
+      task.tg_chat_id,
+      task.tg_thread_id,
+      task.tg_message_id,
+    )
+    await self._storage.update_sync_marker(task.max_chat_id, sent.id)
+
+    await self._queue.enqueue_max2tg(
+      SetReactionTask(
+        tg_chat_id=task.tg_chat_id,
+        tg_message_id=task.tg_message_id,
+        tg_thread_id=task.tg_thread_id,
+      )
+    )
+    logger.info(
+      "max_message_sent",
+      max_chat_id=task.max_chat_id,
+      max_message_id=sent.id,
+      tg_message_id=task.tg_message_id,
+    )
+
+  async def _build_attachments(self, media: list) -> list:
+    if not media:
+      return []
+    bot = await self._bot_holder.wait_bot()
+    result = []
+    async with aiohttp.ClientSession() as session:
+      for item in media:
+        kind = item.kind if hasattr(item, "kind") else item.get("kind", "")
+        if kind == "unsupported":
+          continue
+        path = await download_media_item(bot, session, item, self._tmp_dir)
+        if path is None:
+          logger.warning(
+            "max_worker_media_skipped",
+            kind=kind,
+            file_id=getattr(item, "file_id", None) or item.get("file_id"),
+            url=getattr(item, "url", None) or item.get("url"),
+          )
+          continue
+        if "photo" in kind:
+          result.append(Photo(path=str(path)))
+        elif "video" in kind:
+          result.append(Video(path=str(path)))
+        else:
+          result.append(File(path=str(path)))
+    return result

app/media_transfer.py

@@ -0,0 +1,171 @@
+from pathlib import Path
+from uuid import uuid4
+
+import aiohttp
+import structlog
+
+from app.models.tasks import MediaItem
+
+logger = structlog.get_logger(__name__)
+
+_MAX_CDN_HEADERS = {
+  "User-Agent": (
+    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) "
+    "AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36"
+  ),
+}
+
+
+def tmp_dir(data_dir: str) -> Path:
+  path = Path(data_dir) / "tmp"
+  path.mkdir(parents=True, exist_ok=True)
+  return path
+
+
+def _item_field(item: MediaItem | dict, name: str, default=None):
+  if isinstance(item, MediaItem):
+    return getattr(item, name, default)
+  return item.get(name, default)
+
+
+def _default_file_name(kind: str) -> str:
+  if "photo" in kind:
+    return f"{uuid4().hex}.jpg"
+  if "video" in kind:
+    return f"{uuid4().hex}.mp4"
+  return f"{uuid4().hex}.bin"
+
+
+def resolve_file_name(item: MediaItem | dict) -> str:
+  kind = _item_field(item, "kind", "") or ""
+  file_name = _item_field(item, "file_name")
+  if file_name:
+    return file_name
+  return _default_file_name(kind)
+
+
+async def _download_url(
+  session: aiohttp.ClientSession,
+  url: str,
+  dest: Path,
+) -> bool:
+  try:
+    async with session.get(url, headers=_MAX_CDN_HEADERS) as resp:
+      if resp.status != 200:
+        logger.warning(
+          "media_download_http_error",
+          url=url,
+          status=resp.status,
+        )
+        return False
+      dest.write_bytes(await resp.read())
+    return True
+  except aiohttp.ClientError as exc:
+    logger.warning("media_download_failed", url=url, error=str(exc))
+    return False
+
+
+async def _resolve_max_url(client, item: MediaItem | dict) -> str | None:
+  chat_id = _item_field(item, "max_chat_id")
+  message_id = _item_field(item, "max_message_id")
+  if chat_id is None or message_id is None:
+    return _item_field(item, "url")
+
+  file_id = _item_field(item, "max_file_id")
+  if file_id is not None:
+    file_req = await client.get_file_by_id(chat_id, message_id, file_id)
+    return file_req.url if file_req else None
+
+  video_id = _item_field(item, "max_video_id")
+  if video_id is not None:
+    video = await client.get_video_by_id(chat_id, message_id, video_id)
+    return video.url if video else None
+
+  return _item_field(item, "url")
+
+
+async def download_max_media(
+  client,
+  items: list[dict],
+  dest_dir: Path,
+) -> list[dict]:
+  if not items:
+    return []
+
+  downloaded: list[dict] = []
+  async with aiohttp.ClientSession() as session:
+    for item in items:
+      url = await _resolve_max_url(client, item)
+      if not url:
+        logger.warning(
+          "max_media_url_unresolved",
+          kind=item.get("kind"),
+          max_file_id=item.get("max_file_id"),
+          max_video_id=item.get("max_video_id"),
+        )
+        continue
+
+      file_name = resolve_file_name(item)
+      dest = dest_dir / f"{uuid4().hex}_{file_name}"
+      if not await _download_url(session, url, dest):
+        logger.warning(
+          "max_media_download_skipped",
+          kind=item.get("kind"),
+          max_file_id=item.get("max_file_id"),
+          max_video_id=item.get("max_video_id"),
+        )
+        continue
+
+      stored = dict(item)
+      stored["local_path"] = str(dest)
+      stored.pop("url", None)
+      downloaded.append(stored)
+
+  return downloaded
+
+
+async def download_media_item(
+  bot,
+  session: aiohttp.ClientSession,
+  item: MediaItem | dict,
+  dest_dir: Path,
+  *,
+  max_client=None,
+) -> Path | None:
+  local_path = _item_field(item, "local_path")
+  if local_path:
+    path = Path(local_path)
+    if path.is_file():
+      return path
+    logger.warning("media_local_path_missing", path=local_path)
+
+  file_id = _item_field(item, "file_id")
+  file_name = resolve_file_name(item)
+
+  if file_id:
+    tg_file = await bot.get_file(file_id)
+    if tg_file.file_path is None:
+      return None
+    dest = dest_dir / file_name
+    await bot.download_file(tg_file.file_path, destination=dest)
+    return dest
+
+  url = _item_field(item, "url")
+  if url is None and max_client is not None:
+    url = await _resolve_max_url(max_client, item)
+
+  if url:
+    dest = dest_dir / file_name
+    if await _download_url(session, url, dest):
+      return dest
+    return None
+
+  return None
+
+
+def cleanup_paths(paths: list[Path]) -> None:
+  for path in paths:
+    try:
+      path.unlink(missing_ok=True)
+    except OSError:
+      logger.warning("media_temp_cleanup_failed", path=str(path))

app/models/domain.py

@@ -0,0 +1,36 @@
+from dataclasses import dataclass
+
+
+@dataclass(slots=True)
+class ChatMapping:
+  max_chat_id: int
+  tg_chat_id: int
+  tg_thread_id: int
+  display_name: str
+  is_dm: bool
+
+
+@dataclass(slots=True)
+class MaxIncomingMessage:
+  max_chat_id: int
+  max_message_id: int
+  text: str
+  sender_id: int | None
+  sender_name: str | None
+  is_dm: bool
+  chat_title: str
+  reply_to_max_message_id: int | None
+  media: list[dict]
+
+
+@dataclass(slots=True)
+class TgIncomingMessage:
+  tg_chat_id: int
+  tg_message_id: int
+  tg_thread_id: int | None
+  text: str
+  author_name: str
+  author_username: str | None
+  is_bot: bool
+  reply_to_tg_message_id: int | None
+  media: list[dict]

app/models/tasks.py

@@ -0,0 +1,77 @@
+from enum import Enum
+from typing import Any
+
+from pydantic import BaseModel, Field
+
+
+class TaskKind(str, Enum):
+  SEND_TO_TG = "send_to_tg"
+  SET_REACTION = "set_reaction"
+  NOTIFY_FALLBACK = "notify_fallback"
+  SEND_TO_MAX = "send_to_max"
+
+
+class MediaItem(BaseModel):
+  kind: str
+  url: str | None = None
+  file_id: str | None = None
+  file_name: str | None = None
+  mime_type: str | None = None
+  caption: str | None = None
+  local_path: str | None = None
+  max_chat_id: int | None = None
+  max_message_id: int | None = None
+  max_file_id: int | None = None
+  max_video_id: int | None = None
+
+
+class Max2TgTask(BaseModel):
+  kind: TaskKind = TaskKind.SEND_TO_TG
+  max_chat_id: int
+  max_message_id: int
+  text: str
+  sender_name: str | None = None
+  is_dm: bool = False
+  chat_title: str
+  needs_new_topic: bool = False
+  reply_to_tg_message_id: int | None = None
+  media: list[MediaItem] = Field(default_factory=list)
+
+
+class SetReactionTask(BaseModel):
+  kind: TaskKind = TaskKind.SET_REACTION
+  tg_chat_id: int
+  tg_message_id: int
+  tg_thread_id: int | None = None
+  emoji: str = "🦄"
+
+
+class NotifyFallbackTask(BaseModel):
+  kind: TaskKind = TaskKind.NOTIFY_FALLBACK
+  title: str
+  details: str
+
+
+class Tg2MaxTask(BaseModel):
+  kind: TaskKind = TaskKind.SEND_TO_MAX
+  max_chat_id: int
+  text: str
+  tg_chat_id: int
+  tg_message_id: int
+  tg_thread_id: int | None = None
+  reply_to_max_message_id: int | None = None
+  media: list[MediaItem] = Field(default_factory=list)
+
+
+def parse_queue_payload(data: str) -> Max2TgTask | SetReactionTask | NotifyFallbackTask | Tg2MaxTask:
+  raw: dict[str, Any] = __import__("json").loads(data)
+  kind = TaskKind(raw.get("kind", TaskKind.SEND_TO_TG))
+  if kind == TaskKind.SEND_TO_TG:
+    return Max2TgTask.model_validate(raw)
+  if kind == TaskKind.SET_REACTION:
+    return SetReactionTask.model_validate(raw)
+  if kind == TaskKind.NOTIFY_FALLBACK:
+    return NotifyFallbackTask.model_validate(raw)
+  if kind == TaskKind.SEND_TO_MAX:
+    return Tg2MaxTask.model_validate(raw)
+  raise ValueError(f"Unknown task kind: {kind}")

app/queue/protocols.py

@@ -0,0 +1,17 @@
+from typing import Protocol
+
+from app.models.tasks import Max2TgTask, NotifyFallbackTask, SetReactionTask, Tg2MaxTask
+
+
+class QueuePort(Protocol):
+  async def connect(self) -> None: ...
+
+  async def close(self) -> None: ...
+
+  async def enqueue_max2tg(self, task: Max2TgTask | SetReactionTask | NotifyFallbackTask) -> None: ...
+
+  async def dequeue_max2tg(self, timeout: int = 0) -> Max2TgTask | SetReactionTask | NotifyFallbackTask | None: ...
+
+  async def enqueue_tg2max(self, task: Tg2MaxTask) -> None: ...
+
+  async def dequeue_tg2max(self, timeout: int = 0) -> Tg2MaxTask | None: ...

app/queue/redis_queue.py

@@ -0,0 +1,89 @@
+import asyncio
+import json
+
+import redis.asyncio as redis
+import structlog
+from redis.exceptions import TimeoutError as RedisTimeoutError
+
+from app.models.tasks import (
+  Max2TgTask,
+  NotifyFallbackTask,
+  SetReactionTask,
+  Tg2MaxTask,
+  parse_queue_payload,
+)
+from app.queue.protocols import QueuePort
+
+MAX2TG_QUEUE = "max2tg_queue"
+TG2MAX_QUEUE = "tg2max_queue"
+
+logger = structlog.get_logger(__name__)
+
+
+class RedisQueue(QueuePort):
+  def __init__(self, redis_url: str) -> None:
+    self._redis_url = redis_url
+    self._client: redis.Redis | None = None
+
+  async def _blpop(self, queue: str, timeout: int) -> tuple[str, str] | None:
+    assert self._client is not None
+    try:
+      return await self._client.blpop(queue, timeout=timeout or None)
+    except asyncio.CancelledError:
+      raise
+    except RedisTimeoutError as exc:
+      task = asyncio.current_task()
+      if task is not None and task.cancelling():
+        raise asyncio.CancelledError() from exc
+      return None
+
+  async def connect(self) -> None:
+    self._client = redis.from_url(self._redis_url, decode_responses=True)
+
+  async def close(self) -> None:
+    if self._client is not None:
+      await self._client.aclose()
+
+  async def enqueue_max2tg(
+    self, task: Max2TgTask | SetReactionTask | NotifyFallbackTask
+  ) -> None:
+    assert self._client is not None
+    await self._client.rpush(MAX2TG_QUEUE, task.model_dump_json())
+    logger.debug("queue_enqueued", queue=MAX2TG_QUEUE, kind=task.kind)
+
+  async def dequeue_max2tg(
+    self, timeout: int = 0
+  ) -> Max2TgTask | SetReactionTask | NotifyFallbackTask | None:
+    assert self._client is not None
+    result = await self._blpop(MAX2TG_QUEUE, timeout=timeout)
+    if result is None:
+      return None
+    _, payload = result
+    task = parse_queue_payload(payload)
+    logger.debug("queue_dequeued", queue=MAX2TG_QUEUE, kind=task.kind)
+    return task
+
+  async def enqueue_tg2max(self, task: Tg2MaxTask) -> None:
+    assert self._client is not None
+    await self._client.rpush(TG2MAX_QUEUE, task.model_dump_json())
+    logger.debug(
+      "queue_enqueued",
+      queue=TG2MAX_QUEUE,
+      kind=task.kind,
+      tg_message_id=task.tg_message_id,
+    )
+
+  async def dequeue_tg2max(self, timeout: int = 0) -> Tg2MaxTask | None:
+    assert self._client is not None
+    result = await self._blpop(TG2MAX_QUEUE, timeout=timeout)
+    if result is None:
+      return None
+    _, payload = result
+    data = json.loads(payload)
+    task = Tg2MaxTask.model_validate(data)
+    logger.debug(
+      "queue_dequeued",
+      queue=TG2MAX_QUEUE,
+      tg_message_id=task.tg_message_id,
+    )
+    return task

app/router/router.py

@@ -0,0 +1,161 @@
+import structlog
+
+from app.models.domain import MaxIncomingMessage, TgIncomingMessage
+from app.models.tasks import Max2TgTask, MediaItem, NotifyFallbackTask, Tg2MaxTask
+from app.queue.protocols import QueuePort
+from app.storage.protocols import StoragePort
+from app.topic_locks import TopicLockRegistry
+
+logger = structlog.get_logger(__name__)
+
+
+class MessageRouter:
+  """Маршрутизация сообщений между MAX и Telegram через очереди и хранилище."""
+
+  def __init__(
+    self,
+    storage: StoragePort,
+    queue: QueuePort,
+    forum_channel_id: int,
+    topic_locks: TopicLockRegistry,
+  ) -> None:
+    self._storage = storage
+    self._queue = queue
+    self._forum_channel_id = forum_channel_id
+    self._topic_locks = topic_locks
+
+  async def handle_max_message(self, message: MaxIncomingMessage) -> bool:
+    logger.debug(
+      "router_max_message_received",
+      max_chat_id=message.max_chat_id,
+      message_id=message.max_message_id,
+      text_len=len(message.text),
+      media_count=len(message.media),
+    )
+    if message.max_chat_id is None or message.max_message_id is None:
+      logger.warning(
+        "router_max_message_rejected",
+        reason="missing_ids",
+        max_chat_id=message.max_chat_id,
+        message_id=message.max_message_id,
+      )
+      return False
+
+    async with self._topic_locks.lock(message.max_chat_id):
+      mapping = await self._storage.get_mapping_by_max_chat(message.max_chat_id)
+    needs_new_topic = mapping is None
+    if mapping is not None:
+      logger.debug(
+        "router_mapping_found",
+        max_chat_id=message.max_chat_id,
+        thread_id=mapping.tg_thread_id,
+      )
+
+    reply_to_tg: int | None = None
+    if message.reply_to_max_message_id is not None:
+      link = await self._storage.get_tg_message_by_max(
+        message.max_chat_id, message.reply_to_max_message_id
+      )
+      if link:
+        reply_to_tg = link[2]
+        logger.debug(
+          "router_reply_mapped",
+          max_reply_to=message.reply_to_max_message_id,
+          tg_reply_to=reply_to_tg,
+        )
+      else:
+        logger.debug(
+          "router_reply_not_found",
+          max_chat_id=message.max_chat_id,
+          max_reply_to=message.reply_to_max_message_id,
+        )
+
+    media = [MediaItem.model_validate(item) for item in message.media]
+
+    task = Max2TgTask(
+      max_chat_id=message.max_chat_id,
+      max_message_id=message.max_message_id,
+      text=message.text,
+      sender_name=message.sender_name,
+      is_dm=message.is_dm,
+      chat_title=message.chat_title,
+      needs_new_topic=needs_new_topic,
+      reply_to_tg_message_id=reply_to_tg,
+      media=media,
+    )
+    await self._queue.enqueue_max2tg(task)
+    logger.info(
+      "max_message_enqueued",
+      max_chat_id=message.max_chat_id,
+      message_id=message.max_message_id,
+      needs_new_topic=needs_new_topic,
+    )
+    return True
+
+  async def handle_tg_message(self, message: TgIncomingMessage) -> bool:
+    logger.debug(
+      "router_tg_message_received",
+      tg_chat_id=message.tg_chat_id,
+      tg_message_id=message.tg_message_id,
+      thread_id=message.tg_thread_id,
+      text_len=len(message.text),
+    )
+    if message.is_bot:
+      logger.debug("router_tg_message_skipped", reason="is_bot")
+      return False
+
+    if message.tg_chat_id != self._forum_channel_id:
+      logger.debug(
+        "router_tg_message_skipped",
+        reason="wrong_chat",
+        tg_chat_id=message.tg_chat_id,
+      )
+      return False
+
+    if message.tg_thread_id is None:
+      logger.debug("router_tg_message_skipped", reason="no_thread_id")
+      return False
+
+    mapping = await self._storage.get_mapping_by_tg_thread(
+      message.tg_chat_id, message.tg_thread_id
+    )
+    if mapping is None:
+      logger.debug(
+        "tg_message_no_mapping",
+        tg_chat_id=message.tg_chat_id,
+        thread_id=message.tg_thread_id,
+      )
+      return False
+
+    reply_to_max: int | None = None
+    if message.reply_to_tg_message_id is not None:
+      link = await self._storage.get_max_message_by_tg(
+        message.tg_chat_id, message.reply_to_tg_message_id
+      )
+      if link:
+        reply_to_max = link[1]
+
+    media = [MediaItem.model_validate(item) for item in message.media]
+
+    task = Tg2MaxTask(
+      max_chat_id=mapping.max_chat_id,
+      text=message.text,
+      tg_chat_id=message.tg_chat_id,
+      tg_message_id=message.tg_message_id,
+      tg_thread_id=message.tg_thread_id,
+      reply_to_max_message_id=reply_to_max,
+      media=media,
+    )
+    await self._queue.enqueue_tg2max(task)
+    logger.info(
+      "tg_message_enqueued",
+      tg_message_id=message.tg_message_id,
+      max_chat_id=mapping.max_chat_id,
+    )
+    return True
+
+  async def notify_error(self, title: str, details: str) -> None:
+    logger.error("router_notify_error", title=title, details=details)
+    await self._queue.enqueue_max2tg(
+      NotifyFallbackTask(title=title, details=details)
+    )

app/storage/database.py

@@ -0,0 +1,19 @@
+from sqlalchemy import event
+from sqlalchemy.ext.asyncio import AsyncEngine, async_sessionmaker, create_async_engine
+
+
+def create_engine(database_url: str) -> AsyncEngine:
+  engine = create_async_engine(database_url, echo=False)
+
+  @event.listens_for(engine.sync_engine, "connect")
+  def _set_sqlite_pragma(dbapi_conn, _record) -> None:
+    cursor = dbapi_conn.cursor()
+    cursor.execute("PRAGMA journal_mode=WAL")
+    cursor.execute("PRAGMA synchronous=NORMAL")
+    cursor.close()
+
+  return engine
+
+
+def create_session_factory(engine: AsyncEngine) -> async_sessionmaker:
+  return async_sessionmaker(engine, expire_on_commit=False)

app/storage/protocols.py

@@ -0,0 +1,38 @@
+from typing import Protocol
+
+from app.models.domain import ChatMapping
+
+
+class StoragePort(Protocol):
+  async def init(self) -> None: ...
+
+  async def get_mapping_by_max_chat(self, max_chat_id: int) -> ChatMapping | None: ...
+
+  async def get_mapping_by_tg_thread(
+    self, tg_chat_id: int, tg_thread_id: int
+  ) -> ChatMapping | None: ...
+
+  async def save_mapping(self, mapping: ChatMapping) -> None: ...
+
+  async def list_mappings(self) -> list[ChatMapping]: ...
+
+  async def get_sync_marker(self, max_chat_id: int) -> int | None: ...
+
+  async def update_sync_marker(self, max_chat_id: int, message_id: int) -> None: ...
+
+  async def save_message_link(
+    self,
+    max_chat_id: int,
+    max_message_id: int,
+    tg_chat_id: int,
+    tg_thread_id: int,
+    tg_message_id: int,
+  ) -> None: ...
+
+  async def get_tg_message_by_max(
+    self, max_chat_id: int, max_message_id: int
+  ) -> tuple[int, int, int] | None: ...
+
+  async def get_max_message_by_tg(
+    self, tg_chat_id: int, tg_message_id: int
+  ) -> tuple[int, int] | None: ...

app/storage/repository.py

@@ -0,0 +1,157 @@
+from sqlalchemy import Column, Integer, String, Boolean, select
+from sqlalchemy.ext.asyncio import AsyncSession, async_sessionmaker
+from sqlalchemy.orm import DeclarativeBase
+
+from app.models.domain import ChatMapping
+from app.storage.protocols import StoragePort
+
+
+class Base(DeclarativeBase):
+  pass
+
+
+class ChatMappingRow(Base):
+  __tablename__ = "chat_mappings"
+
+  max_chat_id = Column(Integer, primary_key=True)
+  tg_chat_id = Column(Integer, nullable=False)
+  tg_thread_id = Column(Integer, nullable=False)
+  display_name = Column(String, nullable=False)
+  is_dm = Column(Boolean, nullable=False, default=False)
+
+
+class SyncMarkerRow(Base):
+  __tablename__ = "sync_markers"
+
+  max_chat_id = Column(Integer, primary_key=True)
+  last_processed_message_id = Column(Integer, nullable=False, default=0)
+
+
+class MessageLinkRow(Base):
+  __tablename__ = "message_links"
+
+  max_chat_id = Column(Integer, primary_key=True)
+  max_message_id = Column(Integer, primary_key=True)
+  tg_chat_id = Column(Integer, nullable=False)
+  tg_thread_id = Column(Integer, nullable=False)
+  tg_message_id = Column(Integer, nullable=False)
+
+
+class SqliteStorage(StoragePort):
+  def __init__(self, session_factory: async_sessionmaker[AsyncSession]) -> None:
+    self._session_factory = session_factory
+
+  async def init(self) -> None:
+    async with self._session_factory() as session:
+      async with session.begin():
+        conn = await session.connection()
+        await conn.run_sync(Base.metadata.create_all)
+
+  async def get_mapping_by_max_chat(self, max_chat_id: int) -> ChatMapping | None:
+    async with self._session_factory() as session:
+      row = await session.get(ChatMappingRow, max_chat_id)
+      if row is None:
+        return None
+      return self._to_mapping(row)
+
+  async def get_mapping_by_tg_thread(
+    self, tg_chat_id: int, tg_thread_id: int
+  ) -> ChatMapping | None:
+    async with self._session_factory() as session:
+      stmt = select(ChatMappingRow).where(
+        ChatMappingRow.tg_chat_id == tg_chat_id,
+        ChatMappingRow.tg_thread_id == tg_thread_id,
+      )
+      row = (await session.execute(stmt)).scalar_one_or_none()
+      if row is None:
+        return None
+      return self._to_mapping(row)
+
+  async def save_mapping(self, mapping: ChatMapping) -> None:
+    async with self._session_factory() as session:
+      async with session.begin():
+        row = await session.get(ChatMappingRow, mapping.max_chat_id)
+        if row is None:
+          session.add(
+            ChatMappingRow(
+              max_chat_id=mapping.max_chat_id,
+              tg_chat_id=mapping.tg_chat_id,
+              tg_thread_id=mapping.tg_thread_id,
+              display_name=mapping.display_name,
+              is_dm=mapping.is_dm,
+            )
+          )
+        else:
+          row.tg_chat_id = mapping.tg_chat_id
+          row.tg_thread_id = mapping.tg_thread_id
+          row.display_name = mapping.display_name
+          row.is_dm = mapping.is_dm
+
+  async def list_mappings(self) -> list[ChatMapping]:
+    async with self._session_factory() as session:
+      rows = (await session.execute(select(ChatMappingRow))).scalars().all()
+      return [self._to_mapping(row) for row in rows]
+
+  async def get_sync_marker(self, max_chat_id: int) -> int | None:
+    async with self._session_factory() as session:
+      row = await session.get(SyncMarkerRow, max_chat_id)
+      return row.last_processed_message_id if row else None
+
+  async def update_sync_marker(self, max_chat_id: int, message_id: int) -> None:
+    async with self._session_factory() as session:
+      async with session.begin():
+        await session.merge(
+          SyncMarkerRow(max_chat_id=max_chat_id, last_processed_message_id=message_id)
+        )
+
+  async def save_message_link(
+    self,
+    max_chat_id: int,
+    max_message_id: int,
+    tg_chat_id: int,
+    tg_thread_id: int,
+    tg_message_id: int,
+  ) -> None:
+    async with self._session_factory() as session:
+      async with session.begin():
+        await session.merge(
+          MessageLinkRow(
+            max_chat_id=max_chat_id,
+            max_message_id=max_message_id,
+            tg_chat_id=tg_chat_id,
+            tg_thread_id=tg_thread_id,
+            tg_message_id=tg_message_id,
+          )
+        )
+
+  async def get_tg_message_by_max(
+    self, max_chat_id: int, max_message_id: int
+  ) -> tuple[int, int, int] | None:
+    async with self._session_factory() as session:
+      row = await session.get(MessageLinkRow, (max_chat_id, max_message_id))
+      if row is None:
+        return None
+      return row.tg_chat_id, row.tg_thread_id, row.tg_message_id
+
+  async def get_max_message_by_tg(
+    self, tg_chat_id: int, tg_message_id: int
+  ) -> tuple[int, int] | None:
+    async with self._session_factory() as session:
+      stmt = select(MessageLinkRow).where(
+        MessageLinkRow.tg_chat_id == tg_chat_id,
+        MessageLinkRow.tg_message_id == tg_message_id,
+      )
+      row = (await session.execute(stmt)).scalar_one_or_none()
+      if row is None:
+        return None
+      return row.max_chat_id, row.max_message_id
+
+  @staticmethod
+  def _to_mapping(row: ChatMappingRow) -> ChatMapping:
+    return ChatMapping(
+      max_chat_id=row.max_chat_id,
+      tg_chat_id=row.tg_chat_id,
+      tg_thread_id=row.tg_thread_id,
+      display_name=row.display_name,
+      is_dm=row.is_dm,
+    )

app/telegram_layer/admin.py

@@ -0,0 +1,126 @@
+from aiogram import Dispatcher, F
+from aiogram.enums import ChatType
+from aiogram.filters import Command, CommandObject
+from aiogram.types import Message
+
+from pymax.types.domain.enums import ChatType as MaxChatType
+
+from app.config import Settings
+from app.max_layer.client_holder import MaxClientHolder
+from app.max_layer.formatter import resolve_sender_name
+from app.storage.protocols import StoragePort
+
+
+def register_admin_handlers(
+  dp: Dispatcher,
+  settings: Settings,
+  storage: StoragePort,
+  max_holder: MaxClientHolder,
+) -> None:
+  fallback = (
+    F.chat.type == ChatType.PRIVATE,
+    F.from_user.id == settings.fallback_user_id,
+  )
+
+  @dp.message(Command("start"), *fallback)
+  async def cmd_start(message: Message) -> None:
+    connected = max_holder.ready.is_set()
+    status = "подключён" if connected else "ожидание подключения"
+    await message.answer(
+      "max2telegram bridge\n\n"
+      f"Статус MAX: {status}\n\n"
+      "Команды: /help, /list, /join, /leave, /last_messages"
+    )
+
+  @dp.message(Command("help"), *fallback)
+  async def cmd_help(message: Message) -> None:
+    await message.answer(
+      "/start — статус\n"
+      "/help — справка\n"
+      "/list — активные маппинги\n"
+      "/join <ссылка> — вступить в MAX-группу\n"
+      "/leave <id или название> — выйти из MAX-чата\n"
+      "/last_messages <id или название> — последние 10 сообщений"
+    )
+
+  @dp.message(Command("list"), *fallback)
+  async def cmd_list(message: Message) -> None:
+    mappings = await storage.list_mappings()
+    if not mappings:
+      await message.answer("Маппинги не найдены.")
+      return
+    lines = [
+      f"• {m.display_name}\n  MAX: {m.max_chat_id} → TG thread: {m.tg_thread_id}"
+      for m in mappings
+    ]
+    await message.answer("Активные маппинги:\n\n" + "\n".join(lines))
+
+  @dp.message(Command("join"), *fallback)
+  async def cmd_join(message: Message, command: CommandObject) -> None:
+    if not command.args:
+      await message.answer("Использование: /join <ссылка>")
+      return
+    client = await max_holder.wait_client()
+    try:
+      chat = await client.join_group(command.args.strip())
+      await message.answer(f"Вступили в «{chat.title}» (id={chat.id})")
+    except Exception as exc:
+      await message.answer(f"Ошибка: {exc}")
+
+  @dp.message(Command("leave"), *fallback)
+  async def cmd_leave(message: Message, command: CommandObject) -> None:
+    if not command.args:
+      await message.answer("Использование: /leave <id или название>")
+      return
+    client = await max_holder.wait_client()
+    target = command.args.strip()
+    chat = await _resolve_chat(client, target)
+    if chat is None:
+      await message.answer("Чат не найден.")
+      return
+    if chat.type == MaxChatType.CHANNEL:
+      await client.leave_channel(chat.id)
+    else:
+      await client.leave_group(chat.id)
+    await message.answer(f"Вышли из «{chat.title}» (id={chat.id})")
+
+  @dp.message(Command("last_messages"), *fallback)
+  async def cmd_last_messages(message: Message, command: CommandObject) -> None:
+    if not command.args:
+      await message.answer("Использование: /last_messages <id или название>")
+      return
+    client = await max_holder.wait_client()
+    target = command.args.strip()
+    chat = await _resolve_chat(client, target)
+    if chat is None:
+      await message.answer("Чат не найден.")
+      return
+    history = await client.fetch_history(chat_id=chat.id, backward=10)
+    if not history:
+      await message.answer("Сообщений нет.")
+      return
+    lines = []
+    for msg in reversed(history):
+      sender = f"User {msg.sender}" if msg.sender else "?"
+      if msg.sender:
+        try:
+          user = await client.get_user(msg.sender)
+          sender = resolve_sender_name(user)
+        except Exception:
+          pass
+      text = (msg.text or "")[:200]
+      lines.append(f"[{msg.id}] {sender}: {text}")
+    await message.answer("\n".join(lines) or "Пусто.")
+
+
+async def _resolve_chat(client, target: str):
+  if target.isdigit():
+    try:
+      return await client.get_chat(int(target))
+    except Exception:
+      return None
+  if client.chats:
+    for chat in client.chats:
+      if chat.title and target.lower() in chat.title.lower():
+        return chat
+  return None

app/telegram_layer/bot_holder.py

@@ -0,0 +1,20 @@
+import asyncio
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+  from aiogram import Bot
+
+
+class BotHolder:
+  def __init__(self) -> None:
+    self.bot: Bot | None = None
+    self.ready = asyncio.Event()
+
+  def set_bot(self, bot: "Bot") -> None:
+    self.bot = bot
+    self.ready.set()
+
+  async def wait_bot(self) -> "Bot":
+    await self.ready.wait()
+    assert self.bot is not None
+    return self.bot

app/telegram_layer/formatter.py

@@ -0,0 +1,73 @@
+from aiogram.types import Message
+
+from app.models.domain import TgIncomingMessage
+
+
+def format_tg_author(message: Message) -> tuple[str, str | None]:
+  user = message.from_user
+  if user is None:
+    return "Unknown", None
+  parts = [user.first_name or "", user.last_name or ""]
+  name = " ".join(p for p in parts if p).strip() or (user.username or "User")
+  return name, user.username
+
+
+def format_tg_to_max_text(author_name: str, username: str | None, text: str) -> str:
+  handle = f" (@{username})" if username else ""
+  return f"{author_name}{handle}:\n{text}"
+
+
+def extract_tg_media(message: Message) -> list[dict]:
+  items: list[dict] = []
+  if message.photo:
+    photo = message.photo[-1]
+    items.append({"kind": "photo", "file_id": photo.file_id})
+  elif message.video:
+    items.append({"kind": "video", "file_id": message.video.file_id})
+  elif message.document:
+    items.append(
+      {
+        "kind": "document",
+        "file_id": message.document.file_id,
+        "file_name": message.document.file_name,
+        "mime_type": message.document.mime_type,
+      }
+    )
+  elif message.audio:
+    items.append({"kind": "audio", "file_id": message.audio.file_id})
+  elif message.voice:
+    items.append({"kind": "voice", "file_id": message.voice.file_id})
+  elif message.sticker or message.animation or message.video_note:
+    items.append({"kind": "unsupported", "file_id": None})
+  return items
+
+
+def build_tg_incoming(message: Message, forum_channel_id: int) -> TgIncomingMessage | None:
+  if message.chat.id != forum_channel_id:
+    return None
+  if message.is_topic_message is False and message.message_thread_id is None:
+    return None
+
+  author_name, username = format_tg_author(message)
+  text = message.text or message.caption or ""
+  media = extract_tg_media(message)
+
+  if not text and not media:
+    return None
+
+  if media and not text and any(m.get("kind") == "unsupported" for m in media):
+    text = "[Telegram files]"
+
+  return TgIncomingMessage(
+    tg_chat_id=message.chat.id,
+    tg_message_id=message.message_id,
+    tg_thread_id=message.message_thread_id,
+    text=text,
+    author_name=author_name,
+    author_username=username,
+    is_bot=bool(message.from_user and message.from_user.is_bot),
+    reply_to_tg_message_id=message.reply_to_message.message_id
+    if message.reply_to_message
+    else None,
+    media=media,
+  )

app/telegram_layer/listener.py

@@ -0,0 +1,76 @@
+import structlog
+from aiogram import Bot, Dispatcher, F
+from aiogram.enums import ChatType
+from aiogram.types import Message
+
+from app.config import Settings
+from app.router.router import MessageRouter
+from app.storage.protocols import StoragePort
+from app.telegram_layer.admin import register_admin_handlers
+from app.telegram_layer.bot_holder import BotHolder
+from app.telegram_layer.formatter import build_tg_incoming, format_tg_to_max_text
+
+logger = structlog.get_logger(__name__)
+
+
+class TelegramListener:
+  def __init__(
+    self,
+    settings: Settings,
+    bot_holder: BotHolder,
+    router: MessageRouter,
+    storage: StoragePort,
+    max_holder,
+  ) -> None:
+    self._settings = settings
+    self._bot_holder = bot_holder
+    self._router = router
+    self._storage = storage
+    self._max_holder = max_holder
+    self._bot = Bot(token=settings.tg_bot_token)
+    self._dp = Dispatcher()
+
+  async def run(self) -> None:
+    self._bot_holder.set_bot(self._bot)
+    register_admin_handlers(
+      self._dp,
+      self._settings,
+      self._storage,
+      self._max_holder,
+    )
+    self._dp.message.register(
+      self._on_forum_message,
+      F.chat.id == self._settings.tg_forum_channel_id,
+      F.chat.type == ChatType.SUPERGROUP,
+    )
+    logger.info("telegram_listener_started")
+    try:
+      await self._dp.start_polling(self._bot)
+    except Exception:
+      logger.exception("telegram_polling_failed")
+      raise
+
+  async def _on_forum_message(self, message: Message) -> None:
+    logger.debug(
+      "tg_forum_message_received",
+      message_id=message.message_id,
+      thread_id=message.message_thread_id,
+      has_text=bool(message.text or message.caption),
+    )
+    incoming = build_tg_incoming(message, self._settings.tg_forum_channel_id)
+    if incoming is None:
+      logger.debug("tg_forum_message_skipped", message_id=message.message_id)
+      return
+    incoming.text = format_tg_to_max_text(
+      incoming.author_name,
+      incoming.author_username,
+      incoming.text,
+    )
+    try:
+      await self._router.handle_tg_message(incoming)
+    except Exception:
+      logger.exception("tg_route_failed", message_id=message.message_id)
+      await self._router.notify_error(
+        "Ошибка маршрутизации TG → MAX",
+        f"message_id={message.message_id}",
+      )

app/telegram_layer/worker.py

@@ -0,0 +1,245 @@
+import asyncio
+
+import aiohttp
+import structlog
+from aiogram.types import (
+  FSInputFile,
+  InputMediaDocument,
+  InputMediaPhoto,
+  InputMediaVideo,
+  ReactionTypeEmoji,
+)
+
+from app.config import Settings
+from app.media_transfer import cleanup_paths, download_media_item, resolve_file_name, tmp_dir
+from app.max_layer.client_holder import MaxClientHolder
+from app.max_layer.formatter import format_max_text
+from app.models.domain import ChatMapping, MaxIncomingMessage
+from app.models.tasks import (
+  Max2TgTask,
+  MediaItem,
+  NotifyFallbackTask,
+  SetReactionTask,
+)
+from app.queue.protocols import QueuePort
+from app.storage.protocols import StoragePort
+from app.telegram_layer.bot_holder import BotHolder
+from app.topic_locks import TopicLockRegistry
+
+logger = structlog.get_logger(__name__)
+
+
+class TelegramWorker:
+  def __init__(
+    self,
+    settings: Settings,
+    bot_holder: BotHolder,
+    max_holder: MaxClientHolder,
+    queue: QueuePort,
+    storage: StoragePort,
+    topic_locks: TopicLockRegistry,
+  ) -> None:
+    self._settings = settings
+    self._bot_holder = bot_holder
+    self._max_holder = max_holder
+    self._queue = queue
+    self._storage = storage
+    self._topic_locks = topic_locks
+    self._running = True
+    self._tmp_dir = tmp_dir(self._settings.data_dir)
+
+  async def run(self) -> None:
+    logger.info("tg_worker_started")
+    while self._running:
+      task = await self._queue.dequeue_max2tg(timeout=5)
+      if task is None:
+        continue
+      logger.info("tg_worker_task_received", task_kind=task.kind)
+      try:
+        if isinstance(task, Max2TgTask):
+          await self._send_to_tg(task)
+        elif isinstance(task, SetReactionTask):
+          await self._set_reaction(task)
+        elif isinstance(task, NotifyFallbackTask):
+          await self._notify_fallback(task)
+      except Exception as exc:
+        logger.exception("tg_worker_failed", task_kind=task.kind)
+        if isinstance(task, Max2TgTask):
+          await self._queue.enqueue_max2tg(
+            NotifyFallbackTask(
+              title="Ошибка отправки в Telegram",
+              details=f"max_message_id={task.max_message_id}: {exc}",
+            )
+          )
+      await asyncio.sleep(self._settings.tg_rate_limit_delay_sec)
+
+  async def _send_to_tg(self, task: Max2TgTask) -> None:
+    bot = await self._bot_holder.wait_bot()
+    logger.debug(
+      "tg_worker_send_start",
+      max_chat_id=task.max_chat_id,
+      max_message_id=task.max_message_id,
+      needs_new_topic=task.needs_new_topic,
+      media_count=len(task.media),
+    )
+
+    async with self._topic_locks.lock(task.max_chat_id):
+      mapping = await self._storage.get_mapping_by_max_chat(task.max_chat_id)
+      if mapping is None:
+        topic = await bot.create_forum_topic(
+          chat_id=self._settings.tg_forum_channel_id,
+          name=task.chat_title[:128],
+        )
+        mapping = ChatMapping(
+          max_chat_id=task.max_chat_id,
+          tg_chat_id=self._settings.tg_forum_channel_id,
+          tg_thread_id=topic.message_thread_id,
+          display_name=task.chat_title,
+          is_dm=task.is_dm,
+        )
+        await self._storage.save_mapping(mapping)
+        logger.info(
+          "tg_topic_created",
+          max_chat_id=task.max_chat_id,
+          thread_id=topic.message_thread_id,
+          title=task.chat_title,
+        )
+      else:
+        logger.debug(
+          "tg_topic_reused",
+          max_chat_id=task.max_chat_id,
+          thread_id=mapping.tg_thread_id,
+        )
+
+    assert mapping is not None
+    thread_id = mapping.tg_thread_id
+
+    formatted = format_max_text(
+      MaxIncomingMessage(
+        max_chat_id=task.max_chat_id,
+        max_message_id=task.max_message_id,
+        text=task.text,
+        sender_id=None,
+        sender_name=task.sender_name,
+        is_dm=task.is_dm,
+        chat_title=task.chat_title,
+        reply_to_max_message_id=None,
+        media=[],
+      )
+    )
+
+    sent = await self._dispatch_content(
+      bot, thread_id, formatted, task.media, task.reply_to_tg_message_id
+    )
+    if sent is None:
+      raise RuntimeError("Telegram API returned no message")
+
+    await self._storage.save_message_link(
+      task.max_chat_id,
+      task.max_message_id,
+      mapping.tg_chat_id,
+      mapping.tg_thread_id,
+      sent.message_id,
+    )
+    logger.info(
+      "tg_message_sent",
+      max_message_id=task.max_message_id,
+      tg_message_id=sent.message_id,
+      thread_id=thread_id,
+    )
+
+  async def _dispatch_content(
+    self,
+    bot,
+    thread_id: int,
+    text: str,
+    media: list[MediaItem],
+    reply_to: int | None,
+  ):
+    chat_id = self._settings.tg_forum_channel_id
+    kwargs = {
+      "chat_id": chat_id,
+      "message_thread_id": thread_id,
+      "reply_to_message_id": reply_to,
+    }
+
+    if not media:
+      return await bot.send_message(text=text or " ", **kwargs)
+
+    downloaded: list = []
+    try:
+      max_client = self._max_holder.client
+      async with aiohttp.ClientSession() as session:
+        uploads: list[tuple[MediaItem, FSInputFile]] = []
+        for item in media:
+          path = await download_media_item(
+            bot,
+            session,
+            item,
+            self._tmp_dir,
+            max_client=max_client,
+          )
+          if path is None:
+            logger.warning(
+              "tg_worker_media_skipped",
+              kind=item.kind,
+              file_id=item.file_id,
+              url=item.url,
+            )
+            continue
+          downloaded.append(path)
+          uploads.append(
+            (item, FSInputFile(path, filename=resolve_file_name(item)))
+          )
+
+        if not uploads:
+          fallback = text or "[Telegram files]"
+          return await bot.send_message(text=fallback, **kwargs)
+
+        if len(uploads) == 1:
+          item, upload = uploads[0]
+          if item.kind == "photo":
+            return await bot.send_photo(
+              photo=upload, caption=text or None, **kwargs
+            )
+          if item.kind == "video":
+            return await bot.send_video(
+              video=upload, caption=text or None, **kwargs
+            )
+          return await bot.send_document(
+            document=upload, caption=text or None, **kwargs
+          )
+
+        group = []
+        for idx, (item, upload) in enumerate(uploads):
+          caption = text if idx == 0 else None
+          if item.kind == "photo":
+            group.append(InputMediaPhoto(media=upload, caption=caption))
+          elif item.kind == "video":
+            group.append(InputMediaVideo(media=upload, caption=caption))
+          else:
+            group.append(InputMediaDocument(media=upload, caption=caption))
+
+        messages = await bot.send_media_group(
+          chat_id=chat_id,
+          message_thread_id=thread_id,
+          media=group,
+        )
+        return messages[0]
+    finally:
+      cleanup_paths(downloaded)
+
+  async def _set_reaction(self, task: SetReactionTask) -> None:
+    bot = await self._bot_holder.wait_bot()
+    await bot.set_message_reaction(
+      chat_id=task.tg_chat_id,
+      message_id=task.tg_message_id,
+      reaction=[ReactionTypeEmoji(emoji=task.emoji)],
+    )
+    logger.info("tg_reaction_set", message_id=task.tg_message_id)
+
+  async def _notify_fallback(self, task: NotifyFallbackTask) -> None:
+    bot = await self._bot_holder.wait_bot()
+    text = f"⚠️ {task.title}\n\n{task.details}"
+    await bot.send_message(chat_id=self._settings.fallback_user_id, text=text)
+    logger.warning("fallback_notified", title=task.title)

app/topic_locks.py

@@ -0,0 +1,13 @@
+import asyncio
+
+
+class TopicLockRegistry:
+  def __init__(self) -> None:
+    self._locks: dict[int, asyncio.Lock] = {}
+
+  def lock(self, max_chat_id: int) -> asyncio.Lock:
+    lock = self._locks.get(max_chat_id)
+    if lock is None:
+      lock = asyncio.Lock()
+      self._locks[max_chat_id] = lock
+    return lock

auth.py

@@ -1,34 +0,0 @@
-import asyncio
-import os
-import sys
-
-from dotenv import load_dotenv
-from pymax import MaxClient
-
-
-def main() -> None:
-    load_dotenv()
-
-    phone = os.getenv("MAX_PHONE", "").strip()
-    work_dir = os.getenv("MAX_WORK_DIR", "cache").strip() or "cache"
-
-    if not phone:
-        print("Error: MAX_PHONE environment variable is required", file=sys.stderr)
-        sys.exit(1)
-
-    client = MaxClient(phone=phone, work_dir=work_dir)
-    print(f"Starting Max authentication for {phone}")
-    print(f"Session will be stored in: {work_dir}")
-
-    async def _run() -> None:
-        await client.start()
-        print(f"Authentication successful!")
-        print(f"Me: {client.me.username or client.me.first_name} (id={client.me.id})")
-        print("Session file saved. You can now run the main application.")
-        await client.stop()
-
-    asyncio.run(_run())
-
-
-if __name__ == "__main__":
-    main()

docker-compose.yaml

@@ -1,23 +0,0 @@
-version: '3'
-services:
-  max:
-    build: ./
-    container_name: max
-    restart: always
-    env_file:
-      - ./.env
-    volumes: 
-      - "./cache:/app/cache"
-      - "/etc/hosts:/etc/hosts"
-    ports:
-      - 5004:5000
-    healthcheck:
-      test: ["CMD", "python", "-c", "import urllib.request,sys; import json; r=urllib.request.urlopen('http://127.0.0.1:5000/healthz', timeout=3); sys.exit(0 if r.status==200 else 1)"]
-      interval: 30s
-      timeout: 5s
-      retries: 3
-      start_period: 30s
-    logging:
-      driver: json-file
-      options:
-        max-size: 50m

docker-compose.yml

@@ -0,0 +1,34 @@
+version: '3.8'
+
+services:
+  redis:
+    image: redis:7-alpine
+    restart: always
+    volumes:
+      - ./data/redis:/data
+    command: redis-server --appendonly yes
+
+  app:
+    build: .
+    restart: always
+    depends_on:
+      - redis
+    environment:
+      - MAX_TOKEN=${MAX_TOKEN}
+      - MAX_DEVICE_ID=${MAX_DEVICE_ID}
+      - TG_BOT_TOKEN=${TG_BOT_TOKEN}
+      - TG_FORUM_CHANNEL_ID=${TG_FORUM_CHANNEL_ID}
+      - FALLBACK_USER_ID=${FALLBACK_USER_ID}
+      - DATABASE_URL=sqlite+aiosqlite:///app/data/bridge.db
+      - REDIS_URL=redis://redis:6379/0
+      - TG_RATE_LIMIT_DELAY_SEC=3.5
+      - MAX_RATE_LIMIT_DELAY_SEC=1.0
+      - MAX_RECONNECT_FETCH_LIMIT=50
+      - LOG_LEVEL=INFO
+    volumes:
+      - ./data:/app/data
+    logging:
+      driver: "json-file"
+      options:
+        max-size: "10m"
+        max-file: "3"

requirements.txt

@@ -0,0 +1,10 @@
+maxapi-python>=2.0.0
+aiogram>=3.13.0
+redis[hiredis]>=5.0.0
+sqlalchemy[asyncio]>=2.0.0
+aiosqlite>=0.20.0
+structlog>=24.0.0
+pydantic>=2.0.0
+pydantic-settings>=2.0.0
+aiohttp>=3.9.0
+aiofiles>=23.0.0

src/bridge.py

@@ -1,630 +0,0 @@
-import logging
-from collections.abc import Awaitable, Callable
-from typing import Any
-
-from max_parser import parse_message
-from models import ParsedMessage
-from pymax import MaxClient
-from pymax.types import AudioAttach, FileAttach, Message, PhotoAttach, StickerAttach, VideoAttach
-from storage import BridgeStorage
-from telegram_api import TelegramApiError, TelegramClient
-
-logger = logging.getLogger(__name__)
-
-
-class MaxToTelegramBridge:
-    def __init__(self, max_client: MaxClient, telegram: TelegramClient, storage: BridgeStorage) -> None:
-        self._max_client = max_client
-        self._telegram = telegram
-        self._storage = storage
-
-    async def forward_message(self, max_message: Any) -> None:
-        #if self._is_self_message(max_message):
-        #    logger.debug("Skip self message %s/%s", getattr(max_message, "chat_id", "?"), getattr(max_message, "id", "?"))
-        #    return
-
-        parsed = parse_message(max_message)
-        parsed = await self._enrich_from_max(max_message, parsed)
-
-        if self._storage.was_forwarded(parsed.message_id, parsed.chat_id):
-            logger.debug("Skip duplicated message %s/%s", parsed.chat_id, parsed.message_id)
-            return
-
-        # Формат зависит от маршрута:
-        # - если найден целевой Telegram-чат (не fallback): "Ирина:\n<текст>"
-        # - если fallback: "Ирина / Свободный микрофон:\n<текст>"
-        # Решение о том, включать ли название чата, принимаем после определения маршрута.
-        normalized = parsed.chat_name.strip().casefold()
-        routed = self._storage.get_chat_route(max_chat_title_norm=normalized)
-        if routed:
-            target_chat_id = routed
-            is_fallback = False
-            logger.info("Route Max chat '%s' to Telegram chat %s (bound)", parsed.chat_name, target_chat_id)
-        else:
-            target_chat_id, matched_by_title = await self._telegram.resolve_target_chat_id(parsed.chat_name)
-            if matched_by_title:
-                is_fallback = False
-                logger.info("Route Max chat '%s' to Telegram chat %s", parsed.chat_name, target_chat_id)
-            else:
-                is_fallback = True
-                logger.info(
-                    "Telegram chat '%s' not found, route to fallback user %s",
-                    parsed.chat_name,
-                    target_chat_id,
-                )
-
-        text = self._format_caption(
-            sender_name=parsed.sender_name,
-            chat_name=parsed.chat_name,
-            text=parsed.text,
-            include_chat_name=is_fallback,
-        )
-        text = self._append_unknown_attachment_notice(parsed=parsed, text=text)
-
-        reply_telegram_mid = self._resolve_telegram_reply_to(
-            telegram_chat_id=str(target_chat_id),
-            max_chat_id=str(parsed.chat_id),
-            parsed=parsed,
-        )
-        if parsed.reply_to_max_message_id and reply_telegram_mid is None:
-            text = self._prepend_max_reply_context(parsed, text)
-
-        has_any_payload = bool(text.strip()) or bool(parsed.image_urls) or bool(parsed.video_urls) or bool(parsed.file_urls)
-        if not has_any_payload:
-            text = self._build_fallback_unknown_notice(parsed)
-
-        total_media = len(parsed.image_urls) + len(parsed.video_urls)
-        sent_any = False
-        if total_media > 1:
-            # Отправляем одним альбомом в Telegram (единое сообщение).
-            target_chat_id, sent_messages = await self._send_with_migration_retry(
-                target_chat_id=target_chat_id,
-                max_chat_title_norm=normalized,
-                max_chat_title=parsed.chat_name,
-                send_action=lambda chat_id: self._telegram.send_media_group(
-                    chat_id=chat_id,
-                    image_urls=parsed.image_urls,
-                    video_urls=parsed.video_urls,
-                    caption=text,
-                    reply_to_message_id=reply_telegram_mid,
-                ),
-            )
-            for sent in sent_messages:
-                mid = sent.get("message_id")
-                if mid is None:
-                    continue
-                self._storage.save_mapping(
-                    telegram_chat_id=str(target_chat_id),
-                    telegram_message_id=str(mid),
-                    max_chat_id=str(parsed.chat_id),
-                    max_message_id=str(parsed.message_id),
-                )
-                sent_any = True
-            self._storage.mark_forwarded(parsed.message_id, parsed.chat_id)
-            logger.info(
-                "Forwarded media group %s/%s (images=%s, videos=%s)",
-                parsed.chat_id,
-                parsed.message_id,
-                len(parsed.image_urls),
-                len(parsed.video_urls),
-            )
-            return
-
-        should_send_plain_text = total_media == 0 and not parsed.file_urls and bool(text.strip())
-        if should_send_plain_text:
-            target_chat_id, sent = await self._send_with_migration_retry(
-                target_chat_id=target_chat_id,
-                max_chat_title_norm=normalized,
-                max_chat_title=parsed.chat_name,
-                send_action=lambda chat_id: self._telegram.send_text(
-                    chat_id, text, reply_to_message_id=reply_telegram_mid
-                ),
-            )
-            mid = sent.get("result", {}).get("message_id") if isinstance(sent.get("result"), dict) else None
-            if mid is not None:
-                self._storage.save_mapping(
-                    telegram_chat_id=str(target_chat_id),
-                    telegram_message_id=str(mid),
-                    max_chat_id=str(parsed.chat_id),
-                    max_message_id=str(parsed.message_id),
-                )
-            sent_any = True
-
-        for index, image_url in enumerate(parsed.image_urls):
-            caption = text if not sent_any and index == 0 else None
-            target_chat_id, sent = await self._send_with_migration_retry(
-                target_chat_id=target_chat_id,
-                max_chat_title_norm=normalized,
-                max_chat_title=parsed.chat_name,
-                send_action=lambda chat_id: self._telegram.send_photo(
-                    chat_id,
-                    image_url,
-                    caption=caption,
-                    reply_to_message_id=reply_telegram_mid if not sent_any and index == 0 else None,
-                ),
-            )
-            mid = sent.get("result", {}).get("message_id") if isinstance(sent.get("result"), dict) else None
-            if mid is not None:
-                self._storage.save_mapping(
-                    telegram_chat_id=str(target_chat_id),
-                    telegram_message_id=str(mid),
-                    max_chat_id=str(parsed.chat_id),
-                    max_message_id=str(parsed.message_id),
-                )
-            sent_any = True
-
-        for index, video_url in enumerate(parsed.video_urls):
-            caption = text if not sent_any and index == 0 else None
-            target_chat_id, sent = await self._send_with_migration_retry(
-                target_chat_id=target_chat_id,
-                max_chat_title_norm=normalized,
-                max_chat_title=parsed.chat_name,
-                send_action=lambda chat_id: self._telegram.send_video(
-                    chat_id,
-                    video_url,
-                    caption=caption,
-                    reply_to_message_id=reply_telegram_mid if not sent_any and index == 0 else None,
-                ),
-            )
-            mid = sent.get("result", {}).get("message_id") if isinstance(sent.get("result"), dict) else None
-            if mid is not None:
-                self._storage.save_mapping(
-                    telegram_chat_id=str(target_chat_id),
-                    telegram_message_id=str(mid),
-                    max_chat_id=str(parsed.chat_id),
-                    max_message_id=str(parsed.message_id),
-                )
-            sent_any = True
-
-        for index, file_url in enumerate(parsed.file_urls):
-            caption = text if not sent_any and index == 0 else None
-            file_name = parsed.file_names_by_url.get(file_url)
-            target_chat_id, sent = await self._send_with_migration_retry(
-                target_chat_id=target_chat_id,
-                max_chat_title_norm=normalized,
-                max_chat_title=parsed.chat_name,
-                send_action=lambda chat_id: self._telegram.send_document(
-                    chat_id,
-                    file_url,
-                    file_name=file_name,
-                    caption=caption,
-                    reply_to_message_id=reply_telegram_mid if not sent_any and index == 0 else None,
-                ),
-            )
-            mid = sent.get("result", {}).get("message_id") if isinstance(sent.get("result"), dict) else None
-            if mid is not None:
-                self._storage.save_mapping(
-                    telegram_chat_id=str(target_chat_id),
-                    telegram_message_id=str(mid),
-                    max_chat_id=str(parsed.chat_id),
-                    max_message_id=str(parsed.message_id),
-                )
-            sent_any = True
-
-        if not sent_any:
-            # Последняя страховка: гарантируем уведомление в Telegram даже для пустых/неизвестных payload.
-            fallback_text = text.strip() or self._build_fallback_unknown_notice(parsed)
-            target_chat_id, sent = await self._send_with_migration_retry(
-                target_chat_id=target_chat_id,
-                max_chat_title_norm=normalized,
-                max_chat_title=parsed.chat_name,
-                send_action=lambda chat_id: self._telegram.send_text(
-                    chat_id, fallback_text, reply_to_message_id=reply_telegram_mid
-                ),
-            )
-            mid = sent.get("result", {}).get("message_id") if isinstance(sent.get("result"), dict) else None
-            if mid is not None:
-                self._storage.save_mapping(
-                    telegram_chat_id=str(target_chat_id),
-                    telegram_message_id=str(mid),
-                    max_chat_id=str(parsed.chat_id),
-                    max_message_id=str(parsed.message_id),
-                )
-            sent_any = True
-
-        self._storage.mark_forwarded(parsed.message_id, parsed.chat_id)
-        logger.info(
-            "Forwarded message %s/%s (images=%s, videos=%s, files=%s, unknown=%s)",
-            parsed.chat_id,
-            parsed.message_id,
-            len(parsed.image_urls),
-            len(parsed.video_urls),
-            len(parsed.file_urls),
-            len(parsed.unknown_attachments),
-        )
-
-    async def notify_delivery_failure(self, max_message: Any, error: Exception) -> None:
-        """Best-effort аварийное уведомление, если основной форвардинг упал."""
-        try:
-            parsed = parse_message(max_message)
-            parsed = await self._enrich_from_max(max_message, parsed)
-            body = self._build_fallback_unknown_notice(parsed)
-            body = f"{body}\n\n[bridge-error] {type(error).__name__}: {error}"
-        except Exception:
-            body = f"[!] Сообщение из MAX не доставлено в Telegram из-за ошибки bridge: {type(error).__name__}: {error}"
-
-        fallback_chat_id = self._telegram.fallback_user_id
-        if not fallback_chat_id:
-            logger.error("Cannot send emergency notice: Telegram fallback user id is empty")
-            return
-        try:
-            await self._telegram.send_text(chat_id=fallback_chat_id, text=body)
-            logger.warning("Sent emergency notice to Telegram fallback chat %s", fallback_chat_id)
-        except Exception:
-            logger.exception("Cannot send emergency notice to Telegram")
-
-    async def _send_with_migration_retry(
-        self,
-        *,
-        target_chat_id: str,
-        max_chat_title_norm: str,
-        max_chat_title: str,
-        send_action: Callable[[str], Awaitable[Any]],
-    ) -> tuple[str, Any]:
-        try:
-            sent = await send_action(target_chat_id)
-            return target_chat_id, sent
-        except TelegramApiError as exc:
-            migrated_chat_id = exc.migrate_to_chat_id
-            if not migrated_chat_id or migrated_chat_id == str(target_chat_id):
-                raise
-            logger.warning(
-                "Telegram chat %s upgraded to %s for MAX chat '%s'; update route and retry",
-                target_chat_id,
-                migrated_chat_id,
-                max_chat_title,
-            )
-            self._storage.set_chat_route(
-                max_chat_title_norm=max_chat_title_norm,
-                telegram_chat_id=migrated_chat_id,
-                telegram_chat_title=max_chat_title,
-            )
-            sent = await send_action(migrated_chat_id)
-            return migrated_chat_id, sent
-
-    def _resolve_telegram_reply_to(
-        self, *, telegram_chat_id: str, max_chat_id: str, parsed: ParsedMessage
-    ) -> int | None:
-        if not parsed.reply_to_max_message_id:
-            return None
-        raw = self._storage.get_telegram_message_id_for_max(
-            telegram_chat_id=telegram_chat_id,
-            max_chat_id=max_chat_id,
-            max_message_id=str(parsed.reply_to_max_message_id),
-        )
-        if not raw:
-            return None
-        try:
-            return int(raw)
-        except ValueError:
-            return None
-
-    @staticmethod
-    def _prepend_max_reply_context(parsed: ParsedMessage, body: str) -> str:
-        """Если в Telegram нет исходного сообщения — сохраняем контекст ответа текстом."""
-        prev = (parsed.reply_preview_text or "").strip()
-        if prev:
-            quoted = "\n".join(f"> {line}" for line in prev.splitlines()[:25])
-            return f"↪ ответ в MAX:\n{quoted}\n\n{body}"
-        return f"↪ ответ в MAX (сообщение id={parsed.reply_to_max_message_id})\n\n{body}"
-
-    @staticmethod
-    def _format_caption(*, sender_name: str, chat_name: str, text: str, include_chat_name: bool) -> str:
-        sender_name = (sender_name or "").strip() or "unknown"
-        chat_name = (chat_name or "").strip() or "direct"
-
-        if include_chat_name:
-            header = f"{sender_name} / {chat_name}:"
-        else:
-            header = f"{sender_name}:"
-
-        body = (text or "").strip()
-        if body:
-            return f"{header}\n{body}"
-        return header
-
-    async def _enrich_from_max(self, max_message: Any, parsed: ParsedMessage) -> ParsedMessage:
-        # Имена отправителя и чата берем из API Max, чтобы всегда получить человекочитаемый формат.
-        try:
-            user = await self._max_client.get_user(user_id=max_message.sender)
-            if user and getattr(user, "names", None):
-                first_name = getattr(user.names[0], "name", "")
-                if first_name:
-                    parsed.sender_name = str(first_name)
-        except Exception:
-            logger.debug("Cannot resolve sender name", exc_info=True)
-
-        try:
-            chat = await self._max_client.get_chat(chat_id=max_message.chat_id)
-            title = getattr(chat, "title", None)
-            if title:
-                parsed.chat_name = str(title)
-        except Exception:
-            logger.debug("Cannot resolve chat title", exc_info=True)
-
-        await self._collect_message_attachments(
-            message=max_message,
-            parsed=parsed,
-            source_tag="root",
-        )
-
-        link = getattr(max_message, "link", None)
-        linked_message = getattr(link, "message", None)
-        if linked_message is not None:
-            # Для reply не копируем текст исходного сообщения в тело:
-            # иначе получаем дубль (цитата + тот же текст как новое сообщение).
-            is_reply = bool(parsed.reply_to_max_message_id)
-            if not is_reply and not (parsed.text or "").strip():
-                linked_text = str(getattr(linked_message, "text", "") or "").strip()
-                if linked_text:
-                    parsed.text = linked_text
-            # Для reply нельзя переносить вложения linked_message:
-            # это исходное сообщение, и его медиа не должны отправляться повторно.
-            if not is_reply:
-                await self._collect_message_attachments(
-                    message=linked_message,
-                    parsed=parsed,
-                    source_tag="forward",
-                )
-
-        # Убираем дубли URL, если парсер и enrich нашли одинаковые вложения.
-        parsed.image_urls = list(dict.fromkeys(parsed.image_urls))
-        parsed.video_urls = list(dict.fromkeys(parsed.video_urls))
-        parsed.file_urls = list(dict.fromkeys(parsed.file_urls))
-        parsed.file_names_by_url = {
-            url: name for url, name in parsed.file_names_by_url.items() if url in parsed.file_urls and name
-        }
-        if parsed.file_urls:
-            parsed.unknown_attachments = [
-                x for x in parsed.unknown_attachments if not self._is_file_unknown_marker(x)
-            ]
-        parsed.unknown_attachments = list(dict.fromkeys(parsed.unknown_attachments))
-        return parsed
-
-    async def _collect_message_attachments(
-        self,
-        *,
-        message: Any,
-        parsed: ParsedMessage,
-        source_tag: str,
-    ) -> None:
-        attaches = getattr(message, "attaches", None) or []
-        message_chat_id = getattr(message, "chat_id", None)
-        message_id = getattr(message, "id", None)
-        if message_chat_id is None:
-            message_chat_id = parsed.chat_id
-
-        for attach in attaches:
-            if isinstance(attach, PhotoAttach):
-                parsed.image_urls.extend(self._extract_photo_urls(attach))
-                continue
-
-            if isinstance(attach, VideoAttach):
-                try:
-                    video = await self._max_client.get_video_by_id(
-                        chat_id=message_chat_id,
-                        message_id=message_id,
-                        video_id=attach.video_id,
-                    )
-                    video_url = getattr(video, "url", None)
-                    if video_url:
-                        parsed.video_urls.append(str(video_url))
-                except Exception:
-                    logger.exception("Cannot resolve video URL from Max (%s)", source_tag)
-                continue
-
-            if isinstance(attach, FileAttach):
-                resolved = await self._resolve_file_attach_url(
-                    message_chat_id=message_chat_id,
-                    message_id=message_id,
-                    attach=attach,
-                )
-                if resolved:
-                    parsed.file_urls.append(resolved)
-                    file_name = str(getattr(attach, "name", "") or "").strip()
-                    if file_name:
-                        parsed.file_names_by_url[resolved] = file_name
-                else:
-                    fallback = str(getattr(attach, "name", "") or "").strip()
-                    if fallback:
-                        parsed.text = self._append_missing_file_note(parsed.text, fallback)
-                    else:
-                        parsed.unknown_attachments.append(type(attach).__name__)
-                continue
-
-            if isinstance(attach, AudioAttach):
-                audio_url = str(getattr(attach, "url", "") or "").strip()
-                if audio_url:
-                    parsed.file_urls.append(audio_url)
-                else:
-                    parsed.unknown_attachments.append(type(attach).__name__)
-                continue
-
-            if isinstance(attach, StickerAttach):
-                sticker_url = str(getattr(attach, "url", "") or "").strip()
-                if sticker_url:
-                    parsed.image_urls.append(sticker_url)
-                else:
-                    parsed.unknown_attachments.append(type(attach).__name__)
-                continue
-
-            # Fallback на случай сырого Attach/нестандартного типа:
-            if await self._resolve_generic_file_attach(
-                message_chat_id=message_chat_id,
-                message_id=message_id,
-                attach=attach,
-                parsed=parsed,
-            ):
-                continue
-
-            urls = self._extract_any_urls(attach)
-            if urls:
-                parsed.file_urls.extend(urls)
-                continue
-
-            parsed.unknown_attachments.append(type(attach).__name__)
-
-    async def _resolve_file_attach_url(self, *, message_chat_id: Any, message_id: Any, attach: FileAttach) -> str | None:
-        file_id = getattr(attach, "file_id", None)
-        if file_id is None or message_id is None:
-            return None
-        try:
-            file_info = await self._max_client.get_file_by_id(
-                chat_id=message_chat_id,
-                message_id=message_id,
-                file_id=file_id,
-            )
-            url = getattr(file_info, "url", None)
-            return str(url) if url else None
-        except Exception:
-            logger.exception("Cannot resolve file URL from Max (file_id=%s)", file_id)
-            return None
-
-    async def _resolve_generic_file_attach(
-        self,
-        *,
-        message_chat_id: Any,
-        message_id: Any,
-        attach: Any,
-        parsed: ParsedMessage,
-    ) -> bool:
-        file_id = getattr(attach, "file_id", None)
-        if file_id is None or message_id is None:
-            return False
-        try:
-            file_info = await self._max_client.get_file_by_id(
-                chat_id=message_chat_id,
-                message_id=message_id,
-                file_id=file_id,
-            )
-            url = getattr(file_info, "url", None)
-            if url:
-                resolved = str(url)
-                parsed.file_urls.append(resolved)
-                file_name = str(getattr(attach, "name", "") or "").strip()
-                if file_name:
-                    parsed.file_names_by_url[resolved] = file_name
-                return True
-        except Exception:
-            logger.debug("Cannot resolve generic file attach from Max", exc_info=True)
-        return False
-
-    def _is_self_message(self, max_message: Any) -> bool:
-        sender = getattr(max_message, "sender", None)
-        me = getattr(self._max_client, "me", None)
-        my_id = getattr(me, "id", None)
-        if sender is None or my_id is None:
-            return False
-        return str(sender) == str(my_id)
-
-    def _extract_photo_urls(self, attach: PhotoAttach) -> list[str]:
-        urls: list[str] = []
-        seen_ids: set[int] = set()
-
-        def walk(node: Any) -> None:
-            if node is None:
-                return
-
-            obj_id = id(node)
-            if obj_id in seen_ids:
-                return
-            seen_ids.add(obj_id)
-
-            if isinstance(node, str):
-                if node.startswith("http://") or node.startswith("https://"):
-                    urls.append(node)
-                return
-
-            if isinstance(node, (list, tuple, set)):
-                for item in node:
-                    walk(item)
-                return
-
-            if isinstance(node, dict):
-                for key, value in node.items():
-                    # Поиск всех возможных URL полей, включая альбомы/варианты размеров.
-                    if key in {"base_url", "url", "src", "download_url"} and isinstance(value, str):
-                        if value.startswith("http://") or value.startswith("https://"):
-                            urls.append(value)
-                    else:
-                        walk(value)
-                return
-
-            if hasattr(node, "__dict__"):
-                walk(vars(node))
-
-        walk(attach)
-        return list(dict.fromkeys(urls))
-
-    def _extract_any_urls(self, node: Any) -> list[str]:
-        urls: list[str] = []
-        seen_ids: set[int] = set()
-
-        def walk(value: Any) -> None:
-            if value is None:
-                return
-            obj_id = id(value)
-            if obj_id in seen_ids:
-                return
-            seen_ids.add(obj_id)
-
-            if isinstance(value, str):
-                if value.startswith("http://") or value.startswith("https://"):
-                    urls.append(value)
-                return
-            if isinstance(value, (list, tuple, set)):
-                for item in value:
-                    walk(item)
-                return
-            if isinstance(value, dict):
-                for nested in value.values():
-                    walk(nested)
-                return
-            if hasattr(value, "__dict__"):
-                walk(vars(value))
-
-        walk(node)
-        return list(dict.fromkeys(urls))
-
-    @staticmethod
-    def _is_forward_attach_like(attach: Any) -> bool:
-        name = type(attach).__name__.lower()
-        if "forward" in name or "share" in name or "quote" in name:
-            return True
-        if hasattr(attach, "__dict__"):
-            keys = {str(k).lower() for k in vars(attach).keys()}
-            if {"forward", "forwarded", "forwards", "link", "message", "messages", "origin", "payload"} & keys:
-                return True
-        return False
-
-    @staticmethod
-    def _append_missing_file_note(current_text: str, file_name: str) -> str:
-        text = (current_text or "").strip()
-        note = f"[MAX forwarded file without direct URL] {file_name}"
-        if not text:
-            return note
-        return f"{text}\n{note}"
-
-    @staticmethod
-    def _append_unknown_attachment_notice(*, parsed: ParsedMessage, text: str) -> str:
-        if not parsed.unknown_attachments:
-            return text
-        unknown_preview = ", ".join(parsed.unknown_attachments[:5])
-        suffix = f"\n\n[!] Неизвестный тип вложения из MAX: {unknown_preview}"
-        return f"{text}{suffix}" if text else suffix.strip()
-
-    @staticmethod
-    def _build_fallback_unknown_notice(parsed: ParsedMessage) -> str:
-        base = MaxToTelegramBridge._format_caption(
-            sender_name=parsed.sender_name,
-            chat_name=parsed.chat_name,
-            text=parsed.text,
-            include_chat_name=True,
-        )
-        unknown = ", ".join(parsed.unknown_attachments[:5]) if parsed.unknown_attachments else "unknown"
-        return f"{base}\n\n[!] Неизвестный или пустой тип сообщения из MAX (attachments={unknown})."
-
-    @staticmethod
-    def _is_file_unknown_marker(value: str) -> bool:
-        normalized = str(value or "").strip().casefold()
-        return normalized in {"attachtype.file", "fileattach", "file"}

src/config.py

@@ -1,33 +0,0 @@
-import os
-from dataclasses import dataclass
-
-
-@dataclass(frozen=True)
-class Settings:
-    max_phone: str
-    max_work_dir: str
-    telegram_bot_token: str
-    telegram_fallback_user_id: str
-    sqlite_path: str
-
-
-def _require_env(name: str) -> str:
-    value = os.getenv(name, "").strip()
-    if not value:
-        raise ValueError(f"Environment variable {name} is required")
-    return value
-
-
-def load_settings() -> Settings:
-    max_work_dir = os.getenv("MAX_WORK_DIR", "cache").strip() or "cache"
-    sqlite_env = os.getenv("SQLITE_PATH", "").strip()
-    sqlite_default = os.path.join(max_work_dir, "max2telegram.db")
-    sqlite_path = sqlite_env or sqlite_default
-
-    return Settings(
-        max_phone=_require_env("MAX_PHONE"),
-        max_work_dir=max_work_dir,
-        telegram_bot_token=_require_env("TELEGRAM_BOT_TOKEN"),
-        telegram_fallback_user_id=_require_env("TELEGRAM_FALLBACK_USER_ID"),
-        sqlite_path=sqlite_path,
-    )

src/health.py

@@ -1,91 +0,0 @@
-import threading
-import time
-from dataclasses import dataclass
-
-
-@dataclass
-class HealthSnapshot:
-    now: float
-    uptime_sec: float
-    telegram_last_ok_ago_sec: float | None
-    telegram_last_error_ago_sec: float | None
-    max_last_ok_ago_sec: float | None
-    max_last_error_ago_sec: float | None
-    max_last_event_ago_sec: float | None
-
-    telegram_healthy: bool
-    max_healthy: bool
-    overall_healthy: bool
-
-
-class HealthState:
-    def __init__(self, *, unhealthy_after_sec: float = 15 * 60) -> None:
-        self._lock = threading.Lock()
-        self._started_at = time.time()
-        self._unhealthy_after_sec = float(unhealthy_after_sec)
-
-        self._telegram_last_ok: float | None = None
-        self._telegram_last_error: float | None = None
-
-        self._max_last_ok: float | None = None
-        self._max_last_error: float | None = None
-        self._max_last_event: float | None = None
-
-    def mark_telegram_ok(self) -> None:
-        with self._lock:
-            self._telegram_last_ok = time.time()
-
-    def mark_telegram_error(self) -> None:
-        with self._lock:
-            self._telegram_last_error = time.time()
-
-    def mark_max_ok(self) -> None:
-        with self._lock:
-            self._max_last_ok = time.time()
-
-    def mark_max_error(self) -> None:
-        with self._lock:
-            self._max_last_error = time.time()
-
-    def mark_max_event(self) -> None:
-        with self._lock:
-            self._max_last_event = time.time()
-
-    def snapshot(self) -> HealthSnapshot:
-        now = time.time()
-        with self._lock:
-            started_at = self._started_at
-            unhealthy_after = self._unhealthy_after_sec
-
-            t_ok = self._telegram_last_ok
-            t_err = self._telegram_last_error
-            m_ok = self._max_last_ok
-            m_err = self._max_last_error
-            m_evt = self._max_last_event
-
-        def ago(ts: float | None) -> float | None:
-            if ts is None:
-                return None
-            return max(0.0, now - ts)
-
-        telegram_last_ok_ago = ago(t_ok)
-        max_last_ok_ago = ago(m_ok)
-
-        telegram_healthy = telegram_last_ok_ago is not None and telegram_last_ok_ago <= unhealthy_after
-        max_healthy = max_last_ok_ago is not None and max_last_ok_ago <= unhealthy_after
-
-        overall_healthy = telegram_healthy and max_healthy
-
-        return HealthSnapshot(
-            now=now,
-            uptime_sec=max(0.0, now - started_at),
-            telegram_last_ok_ago_sec=telegram_last_ok_ago,
-            telegram_last_error_ago_sec=ago(t_err),
-            max_last_ok_ago_sec=max_last_ok_ago,
-            max_last_error_ago_sec=ago(m_err),
-            max_last_event_ago_sec=ago(m_evt),
-            telegram_healthy=telegram_healthy,
-            max_healthy=max_healthy,
-            overall_healthy=overall_healthy,
-        )
-

src/health_web.py

@@ -1,79 +0,0 @@
-import json
-import logging
-import threading
-from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
-from typing import Any
-
-from health import HealthState
-
-logger = logging.getLogger(__name__)
-
-
-class _Handler(BaseHTTPRequestHandler):
-    health: HealthState
-
-    def log_message(self, format: str, *args: Any) -> None:  # noqa: A003
-        # Убираем спам от http.server, оставляем только наши логи.
-        logger.debug("health_http " + format, *args)
-
-    def _send_json(self, status: int, payload: dict[str, Any]) -> None:
-        body = json.dumps(payload, ensure_ascii=False).encode("utf-8")
-        self.send_response(status)
-        self.send_header("Content-Type", "application/json; charset=utf-8")
-        self.send_header("Content-Length", str(len(body)))
-        self.end_headers()
-        self.wfile.write(body)
-
-    def do_GET(self) -> None:  # noqa: N802
-        if self.path in {"/livez", "/live", "/"}:
-            snap = self.health.snapshot()
-            self._send_json(
-                200,
-                {
-                    "status": "live",
-                    "uptime_sec": snap.uptime_sec,
-                },
-            )
-            return
-
-        if self.path in {"/healthz", "/health"}:
-            snap = self.health.snapshot()
-            status = 200 if snap.overall_healthy else 503
-            self._send_json(
-                status,
-                {
-                    "status": "ok" if snap.overall_healthy else "unhealthy",
-                    "telegram": {
-                        "healthy": snap.telegram_healthy,
-                        "last_ok_ago_sec": snap.telegram_last_ok_ago_sec,
-                        "last_error_ago_sec": snap.telegram_last_error_ago_sec,
-                    },
-                    "max": {
-                        "healthy": snap.max_healthy,
-                        "last_ok_ago_sec": snap.max_last_ok_ago_sec,
-                        "last_error_ago_sec": snap.max_last_error_ago_sec,
-                        "last_event_ago_sec": snap.max_last_event_ago_sec,
-                    },
-                    "uptime_sec": snap.uptime_sec,
-                },
-            )
-            return
-
-        self._send_json(404, {"error": "not_found"})
-
-
-def start_health_server(*, host: str, port: int, health: HealthState) -> threading.Thread:
-    class Handler(_Handler):
-        pass
-
-    Handler.health = health
-    server = ThreadingHTTPServer((host, port), Handler)
-
-    def _run() -> None:
-        logger.info("Health server listening on %s:%s", host, port)
-        server.serve_forever(poll_interval=0.5)
-
-    thread = threading.Thread(target=_run, name="health-http", daemon=True)
-    thread.start()
-    return thread
-

src/main.py

@@ -1,101 +0,0 @@
-import asyncio
-import logging
-
-from pymax import MaxClient, Message
-from dotenv import load_dotenv
-
-from bridge import MaxToTelegramBridge
-from config import load_settings
-from health import HealthState
-from health_web import start_health_server
-from reverse_bridge import TelegramToMaxBridge
-from storage import BridgeStorage
-from telegram_api import TelegramClient
-
-
-def _setup_logging() -> None:
-    logging.basicConfig(
-        level=logging.DEBUG,
-        format="%(asctime)s %(levelname)s %(name)s: %(message)s",
-    )
-
-
-def build_client() -> tuple[MaxClient, MaxToTelegramBridge]:
-    settings = load_settings()
-    max_client = MaxClient(
-        phone=settings.max_phone,
-        work_dir=settings.max_work_dir,
-    )
-    telegram_client = TelegramClient(
-        bot_token=settings.telegram_bot_token,
-        fallback_user_id=settings.telegram_fallback_user_id,
-    )
-    storage = BridgeStorage(settings.sqlite_path)
-    bridge = MaxToTelegramBridge(max_client=max_client, telegram=telegram_client, storage=storage)
-    return max_client, bridge
-
-
-def main() -> None:
-    load_dotenv()
-    _setup_logging()
-    settings = load_settings()
-    max_client = MaxClient(phone=settings.max_phone, work_dir=settings.max_work_dir)
-    telegram_client = TelegramClient(
-        bot_token=settings.telegram_bot_token,
-        fallback_user_id=settings.telegram_fallback_user_id,
-    )
-    storage = BridgeStorage(settings.sqlite_path)
-    bridge = MaxToTelegramBridge(max_client=max_client, telegram=telegram_client, storage=storage)
-    health = HealthState(unhealthy_after_sec=15 * 60)
-    start_health_server(host="0.0.0.0", port=5000, health=health)
-
-    reverse_bridge = TelegramToMaxBridge(max_client=max_client, telegram=telegram_client, storage=storage, health=health)
-    logger = logging.getLogger("max2telegram")
-    reverse_bridge_task: asyncio.Task[None] | None = None
-    max_probe_task: asyncio.Task[None] | None = None
-
-    @max_client.on_start
-    async def on_start() -> None:
-        nonlocal reverse_bridge_task, max_probe_task
-        logger.info("Max client started as %s", max_client.me.id)
-        health.mark_max_ok()
-        if reverse_bridge_task is None or reverse_bridge_task.done():
-            reverse_bridge_task = asyncio.create_task(reverse_bridge.start(), name="reverse-bridge")
-        if max_probe_task is None or max_probe_task.done():
-            max_probe_task = asyncio.create_task(
-                _max_probe_loop(max_client=max_client, health=health),
-                name="max-probe-loop",
-            )
-
-    @max_client.on_message()
-    async def on_message(message: Message) -> None:
-        health.mark_max_event()
-        try:
-            await bridge.forward_message(message)
-        except Exception as exc:
-            logger.exception("Failed to forward Max message")
-            await bridge.notify_delivery_failure(message, exc)
-
-    asyncio.run(max_client.start())
-
-
-async def _max_probe_loop(*, max_client: MaxClient, health: HealthState) -> None:
-    # Best-effort контроль соединения: периодически дергаем API.
-    # Если PyMax разорвет соединение/сломается сессия, это обычно проявится как исключение.
-    await asyncio.sleep(2)
-    while True:
-        try:
-            me = getattr(max_client, "me", None)
-            my_id = getattr(me, "id", None)
-            if my_id is not None:
-                await max_client.get_user(user_id=my_id)
-            health.mark_max_ok()
-        except Exception:
-            health.mark_max_error()
-            logger = logging.getLogger("max2telegram")
-            logger.exception("Max probe failed")
-        await asyncio.sleep(60)
-
-
-if __name__ == "__main__":
-    main()

src/max_parser.py

@@ -1,214 +0,0 @@
-from typing import Any
-
-from models import ParsedMessage
-
-
-def _stringify(value: Any) -> str:
-    if value is None:
-        return ""
-    return str(value).strip()
-
-
-def _get_attr(obj: Any, names: list[str], default: Any = None) -> Any:
-    for name in names:
-        if hasattr(obj, name):
-            value = getattr(obj, name)
-            if value is not None:
-                return value
-    return default
-
-
-def _as_dict(obj: Any) -> dict[str, Any]:
-    if isinstance(obj, dict):
-        return obj
-    if hasattr(obj, "__dict__"):
-        return vars(obj)
-    return {}
-
-
-def _is_image(media_type: str) -> bool:
-    value = media_type.lower()
-    return "image" in value or "photo" in value or value in {"jpg", "jpeg", "png", "webp"}
-
-
-def _is_video(media_type: str) -> bool:
-    value = media_type.lower()
-    return "video" in value or value in {"mp4", "mov", "mkv", "avi"}
-
-
-def _is_forward_like(data: dict[str, Any]) -> bool:
-    media_type = _stringify(data.get("type") or data.get("media_type") or data.get("kind")).lower()
-    if "forward" in media_type or "share" in media_type or "quote" in media_type:
-        return True
-    forward_keys = {
-        "forward",
-        "forwarded",
-        "forwards",
-        "link",
-        "message",
-        "messages",
-        "payload",
-        "quote",
-        "origin",
-    }
-    return any(key in data for key in forward_keys)
-
-
-def _classify_url(url: str, media_type: str) -> str:
-    lowered = url.lower()
-    if _is_image(media_type) or lowered.endswith((".jpg", ".jpeg", ".png", ".webp", ".gif")):
-        return "image"
-    if _is_video(media_type) or lowered.endswith((".mp4", ".mov", ".mkv", ".avi", ".webm")):
-        return "video"
-    return "file"
-
-
-def _collect_urls(node: Any) -> list[str]:
-    urls: list[str] = []
-    seen_ids: set[int] = set()
-
-    def walk(value: Any) -> None:
-        if value is None:
-            return
-        obj_id = id(value)
-        if obj_id in seen_ids:
-            return
-        seen_ids.add(obj_id)
-
-        if isinstance(value, str):
-            if value.startswith("http://") or value.startswith("https://"):
-                urls.append(value.strip())
-            return
-        if isinstance(value, (list, tuple, set)):
-            for item in value:
-                walk(item)
-            return
-        if isinstance(value, dict):
-            for nested in value.values():
-                walk(nested)
-            return
-        if hasattr(value, "__dict__"):
-            walk(vars(value))
-
-    walk(node)
-    return list(dict.fromkeys(urls))
-
-
-def _extract_media_urls(message: Any) -> tuple[list[str], list[str], list[str], list[str]]:
-    image_urls: list[str] = []
-    video_urls: list[str] = []
-    file_urls: list[str] = []
-    unknown_attachments: list[str] = []
-
-    # В PyMax рабочее поле для вложений обычно называется attaches.
-    raw_attachments = _get_attr(message, ["attaches", "attachments", "media", "files"], default=[]) or []
-    for item in raw_attachments:
-        data = _as_dict(item)
-        media_type = _stringify(data.get("type") or data.get("media_type") or data.get("kind"))
-        is_forward_like = _is_forward_like(data)
-        url = _stringify(
-            data.get("base_url")
-            or data.get("url")
-            or data.get("link")
-            or data.get("download_url")
-            or data.get("src")
-        )
-
-        if not url:
-            nested = data.get("file") or data.get("payload")
-            nested_data = _as_dict(nested)
-            url = _stringify(
-                nested_data.get("base_url")
-                or nested_data.get("url")
-                or nested_data.get("link")
-                or nested_data.get("download_url")
-                or nested_data.get("src")
-            )
-            if not media_type:
-                media_type = _stringify(nested_data.get("type") or nested_data.get("media_type"))
-
-        if not url:
-            nested_urls = _collect_urls(item)
-            for nested_url in nested_urls:
-                kind = _classify_url(nested_url, media_type)
-                if kind == "image":
-                    image_urls.append(nested_url)
-                elif kind == "video":
-                    video_urls.append(nested_url)
-                else:
-                    file_urls.append(nested_url)
-            if nested_urls:
-                continue
-
-        if not url:
-            if is_forward_like:
-                # Forward-пакет может не содержать прямого URL в верхнем уровне;
-                # текст/медиа достанем рекурсивно в других этапах.
-                continue
-            kind = media_type or _stringify(type(item).__name__) or "unknown"
-            unknown_attachments.append(kind)
-            continue
-
-        if _is_image(media_type):
-            image_urls.append(url)
-        elif _is_video(media_type):
-            video_urls.append(url)
-        else:
-            file_urls.append(url)
-
-    return image_urls, video_urls, file_urls, unknown_attachments
-
-
-def _extract_max_reply(message: Any) -> tuple[str | None, str | None]:
-    """Извлекает id сообщения MAX, на которое ответили, и короткий превью-текст (если есть)."""
-    link = _get_attr(message, ["link"], default=None)
-    if link is None:
-        return None, None
-    inner = _get_attr(link, ["message"], default=None)
-    if inner is None:
-        return None, None
-    mid = _stringify(_get_attr(inner, ["id", "message_id", "mid"]))
-    if not mid:
-        return None, None
-    preview = _stringify(_get_attr(inner, ["text", "message", "body"]))
-    if preview and len(preview) > 500:
-        preview = preview[:497] + "..."
-    return mid, preview or None
-
-
-def parse_message(message: Any) -> ParsedMessage:
-    sender = _get_attr(message, ["sender", "sender_name", "author"], default="unknown")
-    sender_data = _as_dict(sender)
-    sender_name = (
-        _stringify(sender_data.get("nickname"))
-        or _stringify(sender_data.get("username"))
-        or _stringify(sender_data.get("name"))
-        or _stringify(sender)
-        or "unknown"
-    )
-
-    chat_name = (
-        _stringify(_get_attr(message, ["chat_title", "chat_name", "group_name"]))
-        or _stringify(_get_attr(message, ["chat"], default=""))
-        or "direct"
-    )
-
-    message_id = _stringify(_get_attr(message, ["id", "message_id", "mid"])) or "unknown-id"
-    chat_id = _stringify(_get_attr(message, ["chat_id", "dialog_id", "peer_id"])) or "unknown-chat"
-    text = _stringify(_get_attr(message, ["text", "message", "body"]))
-
-    image_urls, video_urls, file_urls, unknown_attachments = _extract_media_urls(message)
-    reply_mid, reply_preview = _extract_max_reply(message)
-    return ParsedMessage(
-        message_id=message_id,
-        chat_id=chat_id,
-        sender_name=sender_name,
-        chat_name=chat_name,
-        text=text,
-        image_urls=image_urls,
-        video_urls=video_urls,
-        file_urls=file_urls,
-        unknown_attachments=unknown_attachments,
-        reply_to_max_message_id=reply_mid,
-        reply_preview_text=reply_preview,
-    )

src/models.py

@@ -1,19 +0,0 @@
-from dataclasses import dataclass, field
-
-
-@dataclass
-class ParsedMessage:
-    message_id: str
-    chat_id: str
-    sender_name: str
-    chat_name: str
-    text: str
-    image_urls: list[str] = field(default_factory=list)
-    video_urls: list[str] = field(default_factory=list)
-    file_urls: list[str] = field(default_factory=list)
-    # URL -> исходное имя файла (если удалось определить в MAX).
-    file_names_by_url: dict[str, str] = field(default_factory=dict)
-    unknown_attachments: list[str] = field(default_factory=list)
-    # Ответ в MAX: Message.link указывает на исходное сообщение (тред).
-    reply_to_max_message_id: str | None = None
-    reply_preview_text: str | None = None

src/requirements.txt

@@ -1,3 +0,0 @@
-git+https://github.com/MaxApiTeam/PyMax.git@dev/1.2.6
-requests
-python-dotenv

src/reverse_bridge.py

@@ -1,559 +0,0 @@
-import asyncio
-import logging
-import time
-from dataclasses import dataclass, field
-from typing import Any
-
-from pymax import MaxClient
-from pymax.files import Photo, Video
-
-from storage import BridgeStorage
-from telegram_api import TelegramClient
-from health import HealthState
-from telegram_max_commands import handle_control_command
-
-logger = logging.getLogger(__name__)
-
-
-def _normalize_title(value: str) -> str:
-    return str(value or "").strip().casefold()
-
-
-def _telegram_chat_title(chat: dict[str, Any]) -> str:
-    # для каналов обычно есть title; для групп тоже; в крайнем случае — username
-    return str(chat.get("title") or chat.get("username") or "").strip()
-
-def _format_sender_line(sender: dict[str, Any] | None) -> str:
-    if not isinstance(sender, dict):
-        return "Unknown:"
-
-    first = str(sender.get("first_name") or "").strip()
-    last = str(sender.get("last_name") or "").strip()
-    username = str(sender.get("username") or "").strip()
-
-    full_name = " ".join([p for p in (first, last) if p])
-    if not full_name:
-        full_name = "Unknown"
-
-    if username:
-        return f"{full_name} (@{username}):"
-    return f"{full_name}:"
-
-
-def _format_forward_text(*, sender: dict[str, Any] | None, text: str) -> str:
-    header = _format_sender_line(sender)
-    body = str(text or "").strip()
-    if body:
-        return f"{header}\n{body}"
-    return header
-
-
-def _is_supported_telegram_message(message: dict[str, Any]) -> bool:
-    # Текстовые сообщения и команды.
-    text = message.get("text")
-    if isinstance(text, str) and text.strip():
-        return True
-
-    photos = message.get("photo")
-    has_photo = isinstance(photos, list) and any(isinstance(p, dict) and p.get("file_id") for p in photos)
-    if has_photo:
-        return True
-
-    video = message.get("video")
-    has_video = isinstance(video, dict) and video.get("file_id")
-    if has_video:
-        return True
-
-    for key in ("document", "audio", "voice", "animation", "sticker", "video_note"):
-        value = message.get(key)
-        if isinstance(value, dict) and value.get("file_id"):
-            return True
-
-    return False
-
-
-@dataclass
-class _MediaGroupBuffer:
-    first_seen_monotonic: float
-    updates: list[dict[str, Any]] = field(default_factory=list)
-
-
-class TelegramToMaxBridge:
-    def __init__(
-        self,
-        *,
-        max_client: MaxClient,
-        telegram: TelegramClient,
-        storage: BridgeStorage,
-        health: "HealthState | None" = None,
-    ) -> None:
-        self._max_client = max_client
-        self._telegram = telegram
-        self._storage = storage
-        self._health = health
-        self._max_title_to_id: dict[str, int] = {}
-
-        self._bot_id: str | None = None
-        self._offset: int | None = None
-
-        self._media_groups: dict[tuple[str, str], _MediaGroupBuffer] = {}
-        self._media_group_grace_sec = 1.2
-        self._start_lock = asyncio.Lock()
-        self._is_running = False
-
-    async def start(self) -> None:
-        async with self._start_lock:
-            if self._is_running:
-                logger.warning("Telegram->Max bridge start skipped: poller is already running")
-                return
-            self._is_running = True
-
-        try:
-            me = await self._telegram.get_me()
-            self._bot_id = str(me.get("id") or "")
-            if not self._bot_id:
-                raise RuntimeError("Cannot resolve Telegram bot id (getMe)")
-
-            self._refresh_max_chat_cache()
-            logger.info("Telegram->Max bridge started (bot_id=%s)", self._bot_id)
-
-            while True:
-                try:
-                    updates = await self._telegram.get_updates(offset=self._offset, timeout=25, limit=100)
-                    if self._health:
-                        self._health.mark_telegram_ok()
-                    await self._handle_updates(updates)
-                except Exception:
-                    if self._health:
-                        self._health.mark_telegram_error()
-                    logger.exception("Telegram polling loop error")
-                    # 409 Conflict: где-то еще идет getUpdates (другой инстанс или webhook/второй poller).
-                    # Делаем backoff, чтобы не долбить API.
-                    await asyncio.sleep(10)
-        finally:
-            async with self._start_lock:
-                self._is_running = False
-
-    async def _handle_updates(self, updates: list[dict[str, Any]]) -> None:
-        max_update_id = None
-        for upd in updates:
-            upd_id = upd.get("update_id")
-            if isinstance(upd_id, int):
-                max_update_id = upd_id if max_update_id is None else max(max_update_id, upd_id)
-
-            message = None
-            for container in ("message", "channel_post"):
-                candidate = upd.get(container)
-                if isinstance(candidate, dict):
-                    message = candidate
-                    break
-            if not message:
-                continue
-
-            if not _is_supported_telegram_message(message):
-                continue
-
-            if self._is_own_telegram_message(message):
-                continue
-
-            await self._handle_message(message)
-
-        if max_update_id is not None:
-            self._offset = max_update_id + 1
-
-        await self._flush_ready_media_groups()
-
-    def _is_own_telegram_message(self, message: dict[str, Any]) -> bool:
-        sender = message.get("from")
-        if isinstance(sender, dict):
-            if sender.get("is_bot") is True:
-                # важно: не уйти в цикл на собственных постах бота
-                return True
-            if self._bot_id and str(sender.get("id") or "") == self._bot_id:
-                return True
-        return False
-
-    async def _handle_message(self, message: dict[str, Any]) -> None:
-        chat = message.get("chat")
-        if not isinstance(chat, dict):
-            return
-
-        # Команда привязки чата Telegram к названию чата в MAX (для Max->Telegram маршрутизации).
-        # Обрабатываем раньше control-команд, чтобы /bind_max не попадала как "неизвестная".
-        text = str(message.get("text") or "").strip()
-        cmd = text.split(maxsplit=1)[0].split("@", 1)[0].strip().casefold() if text else ""
-        if cmd == "/bind_max":
-            await self._handle_bind_max_command(message, chat)
-            return
-
-        # Управление MAX через Telegram: только личка боту и только от fallback_user_id.
-        # В этом случае команду не пересылаем в MAX.
-        try:
-            reply = await handle_control_command(message, max_client=self._max_client, telegram=self._telegram)
-        except Exception:
-            logger.exception("Telegram MAX control command handler failed")
-            reply = None
-        if reply is not None:
-            chat_id = str(chat.get("id") or "")
-            if chat_id:
-                try:
-                    await self._telegram.send_text(chat_id=chat_id, text=reply)
-                except Exception:
-                    logger.exception("Cannot send Telegram reply for control command")
-            return
-
-        chat_title = _telegram_chat_title(chat)
-        normalized = _normalize_title(chat_title)
-        max_chat_id = self._resolve_max_chat_id(message=message, normalized_title=normalized, chat=chat)
-        if max_chat_id is None:
-            # требование: если в MAX нет канала/группы — ошибка и не пересылать
-            logger.error("MAX чат с названием '%s' не найден — сообщение не пересылаю", chat_title)
-            return
-
-        telegram_chat_id = str(chat.get("id"))
-        telegram_message_id = str(message.get("message_id"))
-
-        media_group_id = message.get("media_group_id")
-        if media_group_id is not None:
-            key = (telegram_chat_id, str(media_group_id))
-            buf = self._media_groups.get(key)
-            if buf is None:
-                buf = _MediaGroupBuffer(first_seen_monotonic=time.monotonic())
-                self._media_groups[key] = buf
-            buf.updates.append(message)
-            return
-
-        await self._forward_single_message(
-            max_chat_id=max_chat_id,
-            telegram_chat_id=telegram_chat_id,
-            telegram_message_id=telegram_message_id,
-            message=message,
-            media_group_id=None,
-        )
-
-    async def _handle_bind_max_command(self, message: dict[str, Any], chat: dict[str, Any]) -> None:
-        raw = str(message.get("text") or "").strip()
-        chat_id = str(chat.get("id") or "")
-        # формат: /bind_max <точное название чата в MAX>
-        parts = raw.split(maxsplit=1)
-        if len(parts) < 2 or not parts[1].strip():
-            logger.error("bind_max: missing MAX chat title. Use: /bind_max <MAX chat title>")
-            if chat_id:
-                await self._telegram.send_text(chat_id=chat_id, text="Использование: /bind_max <точное название чата в MAX>")
-            return
-
-        max_title = parts[1].strip()
-        norm = _normalize_title(max_title)
-
-        # проверяем, что чат существует в MAX
-        max_chat_id = self._resolve_max_chat_id_by_title(norm)
-        if max_chat_id is None:
-            logger.error("bind_max: MAX чат '%s' не найден — привязку не сохраняю", max_title)
-            if chat_id:
-                await self._telegram.send_text(chat_id=chat_id, text=f"MAX чат '{max_title}' не найден. Привязка не сохранена.")
-            return
-
-        telegram_chat_id = chat_id
-        telegram_title = _telegram_chat_title(chat)
-        self._storage.set_chat_route(
-            max_chat_title_norm=norm,
-            telegram_chat_id=telegram_chat_id,
-            telegram_chat_title=telegram_title,
-        )
-        logger.info(
-            "bind_max: bound MAX '%s' -> Telegram '%s' (%s)",
-            max_title,
-            telegram_title,
-            telegram_chat_id,
-        )
-        if chat_id:
-            await self._telegram.send_text(
-                chat_id=chat_id,
-                text=f"Канал успешно привязан: Telegram '{telegram_title or telegram_chat_id}' -> MAX '{max_title}'.",
-            )
-
-    async def _flush_ready_media_groups(self) -> None:
-        now = time.monotonic()
-        ready: list[tuple[tuple[str, str], _MediaGroupBuffer]] = []
-        for key, buf in self._media_groups.items():
-            if (now - buf.first_seen_monotonic) >= self._media_group_grace_sec:
-                ready.append((key, buf))
-
-        for key, buf in ready:
-            self._media_groups.pop(key, None)
-            telegram_chat_id, media_group_id = key
-            # сообщения альбома приходят отдельно; отправляем в MAX одним сообщением с несколькими attachments
-            await self._forward_media_group(
-                telegram_chat_id=telegram_chat_id,
-                media_group_id=media_group_id,
-                messages=buf.updates,
-            )
-
-    async def _forward_media_group(self, *, telegram_chat_id: str, media_group_id: str, messages: list[dict[str, Any]]) -> None:
-        if not messages:
-            return
-
-        chat = messages[0].get("chat")
-        if not isinstance(chat, dict):
-            return
-        chat_title = _telegram_chat_title(chat)
-        normalized = _normalize_title(chat_title)
-        max_chat_id = self._resolve_max_chat_id_by_title(normalized)
-        if max_chat_id is None:
-            logger.error("MAX чат с названием '%s' не найден — media group не пересылаю", chat_title)
-            return
-
-        # Telegram может прислать несколько элементов с caption только на первом. Берём text/caption с первого, где он есть.
-        raw_text = ""
-        for m in messages:
-            cand = str(m.get("text") or m.get("caption") or "").strip()
-            if cand:
-                raw_text = cand
-                break
-        text = _format_forward_text(sender=messages[0].get("from"), text=raw_text)
-
-        reply_to = self._resolve_reply_to_max_id(max_chat_id=max_chat_id, message=messages[0])
-
-        attachments: list[Any] = []
-        extra_links: list[str] = []
-        for m in messages:
-            extracted, links = await self._extract_attachments(m)
-            attachments.extend(extracted)
-            extra_links.extend(links)
-
-        text = self._append_file_links(text=text, links=extra_links)
-
-        if not text.strip() and not attachments:
-            return
-
-        sent = await self._max_client.send_message(
-            chat_id=max_chat_id,
-            text=text,
-            attachments=attachments if attachments else None,
-            reply_to=reply_to,
-        )
-        if not sent:
-            logger.error("MAX send_message returned empty for media group (chat_id=%s)", max_chat_id)
-            return
-
-        max_message_id = str(getattr(sent, "id", "") or "")
-        if not max_message_id:
-            logger.error("Cannot resolve MAX message id after sending media group (chat_id=%s)", max_chat_id)
-            return
-
-        # Реакция на каждое сообщение альбома в Telegram — best effort.
-        for m in messages:
-            mid = m.get("message_id")
-            if mid is None:
-                continue
-            try:
-                await self._telegram.add_reaction(chat_id=telegram_chat_id, message_id=str(mid), emoji="🦄")
-            except Exception:
-                logger.debug("Cannot add Telegram reaction", exc_info=True)
-
-        for m in messages:
-            tid = str(m.get("message_id"))
-            if tid:
-                self._storage.save_mapping(
-                    telegram_chat_id=telegram_chat_id,
-                    telegram_message_id=tid,
-                    max_chat_id=str(max_chat_id),
-                    max_message_id=max_message_id,
-                    media_group_id=media_group_id,
-                )
-
-        logger.info(
-            "Forwarded Telegram media group %s (count=%s) -> MAX %s/%s",
-            media_group_id,
-            len(messages),
-            max_chat_id,
-            max_message_id,
-        )
-
-    async def _forward_single_message(
-        self,
-        *,
-        max_chat_id: int,
-        telegram_chat_id: str,
-        telegram_message_id: str,
-        message: dict[str, Any],
-        media_group_id: str | None,
-    ) -> None:
-        raw_text = str(message.get("text") or message.get("caption") or "").strip()
-        text = _format_forward_text(sender=message.get("from"), text=raw_text)
-        attachments, extra_links = await self._extract_attachments(message)
-        text = self._append_file_links(text=text, links=extra_links)
-        if not text.strip() and not attachments:
-            return
-
-        reply_to = self._resolve_reply_to_max_id(max_chat_id=max_chat_id, message=message)
-
-        sent = await self._max_client.send_message(
-            chat_id=max_chat_id,
-            text=text,
-            attachments=attachments if attachments else None,
-            reply_to=reply_to,
-        )
-        if not sent:
-            logger.error("MAX send_message returned empty (chat_id=%s)", max_chat_id)
-            return
-
-        max_message_id = str(getattr(sent, "id", "") or "")
-        if not max_message_id:
-            logger.error("Cannot resolve MAX message id after sending (chat_id=%s)", max_chat_id)
-            return
-
-        # Реакция в Telegram: best effort.
-        try:
-            await self._telegram.add_reaction(chat_id=telegram_chat_id, message_id=telegram_message_id, emoji="🦄")
-        except Exception:
-            logger.debug("Cannot add Telegram reaction", exc_info=True)
-
-        self._storage.save_mapping(
-            telegram_chat_id=telegram_chat_id,
-            telegram_message_id=telegram_message_id,
-            max_chat_id=str(max_chat_id),
-            max_message_id=max_message_id,
-            media_group_id=media_group_id,
-        )
-        logger.info("Forwarded Telegram %s/%s -> MAX %s/%s", telegram_chat_id, telegram_message_id, max_chat_id, max_message_id)
-
-    def _resolve_reply_to_max_id(self, *, max_chat_id: int, message: dict[str, Any]) -> str | None:
-        reply = message.get("reply_to_message")
-        if not isinstance(reply, dict):
-            return None
-        reply_mid = reply.get("message_id")
-        if reply_mid is None:
-            return None
-
-        chat = message.get("chat")
-        if not isinstance(chat, dict):
-            return None
-        telegram_chat_id = str(chat.get("id"))
-        mapped = self._storage.get_max_message_id_for_telegram(
-            telegram_chat_id=telegram_chat_id,
-            telegram_message_id=str(reply_mid),
-        )
-        # reply_to в MAX — это id сообщения; если не нашли, просто отправляем без reply
-        return mapped
-
-    def _resolve_max_chat_id(
-        self,
-        *,
-        message: dict[str, Any],
-        normalized_title: str,
-        chat: dict[str, Any],
-    ) -> int | None:
-        # При reply маршрутизируем по исходному сообщению (контекст диалога),
-        # чтобы не зависеть от username/title Telegram-чата.
-        from_reply = self._resolve_max_chat_id_from_reply(message)
-        if from_reply is not None:
-            return from_reply
-
-        if not normalized_title:
-            logger.error("Telegram chat without title/username, skip (chat=%s)", chat)
-            return None
-
-        return self._resolve_max_chat_id_by_title(normalized_title)
-
-    def _resolve_max_chat_id_from_reply(self, message: dict[str, Any]) -> int | None:
-        reply = message.get("reply_to_message")
-        if not isinstance(reply, dict):
-            return None
-        reply_mid = reply.get("message_id")
-        if reply_mid is None:
-            return None
-
-        chat = message.get("chat")
-        if not isinstance(chat, dict):
-            return None
-        telegram_chat_id = str(chat.get("id"))
-
-        max_chat_id = self._storage.get_max_chat_id_for_telegram(
-            telegram_chat_id=telegram_chat_id,
-            telegram_message_id=str(reply_mid),
-        )
-        if not max_chat_id:
-            return None
-        try:
-            return int(max_chat_id)
-        except ValueError:
-            logger.warning(
-                "Invalid max_chat_id '%s' in mapping for Telegram %s/%s",
-                max_chat_id,
-                telegram_chat_id,
-                reply_mid,
-            )
-            return None
-
-    async def _extract_attachments(self, message: dict[str, Any]) -> tuple[list[Any], list[str]]:
-        attachments: list[Any] = []
-        file_links: list[str] = []
-
-        # photo: массив размеров, берём последний (самый большой)
-        photos = message.get("photo")
-        if isinstance(photos, list) and photos:
-            best = None
-            for p in photos:
-                if isinstance(p, dict) and p.get("file_id"):
-                    best = p
-            if best and isinstance(best, dict):
-                file_id = str(best.get("file_id"))
-                if file_id:
-                    try:
-                        url = await self._telegram.get_file_url(file_id)
-                        attachments.append(Photo(url=url))
-                    except Exception:
-                        logger.exception("Cannot fetch Telegram photo URL")
-
-        video = message.get("video")
-        if isinstance(video, dict) and video.get("file_id"):
-            file_id = str(video.get("file_id"))
-            if file_id:
-                try:
-                    url = await self._telegram.get_file_url(file_id)
-                    attachments.append(Video(url=url))
-                except Exception:
-                    logger.exception("Cannot fetch Telegram video URL")
-
-        for key in ("document", "audio", "voice", "animation", "sticker", "video_note"):
-            value = message.get(key)
-            if not isinstance(value, dict):
-                continue
-            file_id = str(value.get("file_id") or "")
-            if not file_id:
-                continue
-            try:
-                url = await self._telegram.get_file_url(file_id)
-                file_links.append(url)
-            except Exception:
-                logger.exception("Cannot fetch Telegram %s URL", key)
-
-        return attachments, file_links
-
-    @staticmethod
-    def _append_file_links(*, text: str, links: list[str]) -> str:
-        uniq_links = list(dict.fromkeys([str(link).strip() for link in links if str(link).strip()]))
-        if not uniq_links:
-            return text
-        links_block = "\n".join(f"- {url}" for url in uniq_links)
-        suffix = f"\n\n[Telegram files]\n{links_block}"
-        return f"{text}{suffix}" if text else suffix.strip()
-
-    def _refresh_max_chat_cache(self) -> None:
-        title_to_id: dict[str, int] = {}
-        for chat in getattr(self._max_client, "chats", []) or []:
-            title = getattr(chat, "title", None)
-            chat_id = getattr(chat, "id", None)
-            if title and chat_id is not None:
-                title_to_id[_normalize_title(str(title))] = int(chat_id)
-        self._max_title_to_id = title_to_id
-
-    def _resolve_max_chat_id_by_title(self, normalized_title: str) -> int | None:
-        chat_id = self._max_title_to_id.get(normalized_title)
-        if chat_id is not None:
-            return chat_id
-        # на всякий случай обновим кэш (например, если добавили чат во время работы)
-        self._refresh_max_chat_cache()
-        return self._max_title_to_id.get(normalized_title)
-

src/storage.py

@@ -1,168 +0,0 @@
-import sqlite3
-from contextlib import closing
-
-
-class BridgeStorage:
-    def __init__(self, db_path: str) -> None:
-        self._db_path = db_path
-        self._init_db()
-
-    def _connect(self) -> sqlite3.Connection:
-        return sqlite3.connect(self._db_path)
-
-    def _init_db(self) -> None:
-        with closing(self._connect()) as conn:
-            conn.execute(
-                """
-                CREATE TABLE IF NOT EXISTS forwarded_messages (
-                    message_id TEXT NOT NULL,
-                    chat_id TEXT NOT NULL,
-                    forwarded_at DATETIME DEFAULT CURRENT_TIMESTAMP,
-                    PRIMARY KEY (message_id, chat_id)
-                )
-                """
-            )
-            conn.execute(
-                """
-                CREATE TABLE IF NOT EXISTS message_mapping (
-                    telegram_chat_id TEXT NOT NULL,
-                    telegram_message_id TEXT NOT NULL,
-                    max_chat_id TEXT NOT NULL,
-                    max_message_id TEXT NOT NULL,
-                    media_group_id TEXT,
-                    created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
-                    PRIMARY KEY (telegram_chat_id, telegram_message_id)
-                )
-                """
-            )
-            conn.execute(
-                "CREATE INDEX IF NOT EXISTS idx_message_mapping_max ON message_mapping (max_chat_id, max_message_id)"
-            )
-            conn.execute(
-                "CREATE INDEX IF NOT EXISTS idx_message_mapping_media_group ON message_mapping (telegram_chat_id, media_group_id)"
-            )
-            conn.execute(
-                """
-                CREATE TABLE IF NOT EXISTS chat_routes (
-                    max_chat_title_norm TEXT PRIMARY KEY,
-                    telegram_chat_id TEXT NOT NULL,
-                    telegram_chat_title TEXT,
-                    created_at DATETIME DEFAULT CURRENT_TIMESTAMP
-                )
-                """
-            )
-            conn.commit()
-
-    def was_forwarded(self, message_id: str, chat_id: str) -> bool:
-        with closing(self._connect()) as conn:
-            row = conn.execute(
-                "SELECT 1 FROM forwarded_messages WHERE message_id = ? AND chat_id = ?",
-                (message_id, chat_id),
-            ).fetchone()
-            return row is not None
-
-    def mark_forwarded(self, message_id: str, chat_id: str) -> None:
-        with closing(self._connect()) as conn:
-            conn.execute(
-                "INSERT OR IGNORE INTO forwarded_messages (message_id, chat_id) VALUES (?, ?)",
-                (message_id, chat_id),
-            )
-            conn.commit()
-
-    def save_mapping(
-        self,
-        *,
-        telegram_chat_id: str,
-        telegram_message_id: str,
-        max_chat_id: str,
-        max_message_id: str,
-        media_group_id: str | None = None,
-    ) -> None:
-        with closing(self._connect()) as conn:
-            conn.execute(
-                """
-                INSERT OR REPLACE INTO message_mapping
-                    (telegram_chat_id, telegram_message_id, max_chat_id, max_message_id, media_group_id)
-                VALUES (?, ?, ?, ?, ?)
-                """,
-                (telegram_chat_id, telegram_message_id, max_chat_id, max_message_id, media_group_id),
-            )
-            conn.commit()
-
-    def get_max_message_id_for_telegram(
-        self, *, telegram_chat_id: str, telegram_message_id: str
-    ) -> str | None:
-        with closing(self._connect()) as conn:
-            row = conn.execute(
-                """
-                SELECT max_message_id
-                FROM message_mapping
-                WHERE telegram_chat_id = ? AND telegram_message_id = ?
-                """,
-                (telegram_chat_id, telegram_message_id),
-            ).fetchone()
-            if not row:
-                return None
-            return str(row[0])
-
-    def get_max_chat_id_for_telegram(
-        self, *, telegram_chat_id: str, telegram_message_id: str
-    ) -> str | None:
-        with closing(self._connect()) as conn:
-            row = conn.execute(
-                """
-                SELECT max_chat_id
-                FROM message_mapping
-                WHERE telegram_chat_id = ? AND telegram_message_id = ?
-                """,
-                (telegram_chat_id, telegram_message_id),
-            ).fetchone()
-            if not row:
-                return None
-            return str(row[0])
-
-    def get_telegram_message_id_for_max(
-        self, *, telegram_chat_id: str, max_chat_id: str, max_message_id: str
-    ) -> str | None:
-        """Обратный поиск: какое сообщение в Telegram соответствует паре MAX chat/message."""
-        with closing(self._connect()) as conn:
-            row = conn.execute(
-                """
-                SELECT telegram_message_id
-                FROM message_mapping
-                WHERE telegram_chat_id = ? AND max_chat_id = ? AND max_message_id = ?
-                ORDER BY telegram_message_id
-                LIMIT 1
-                """,
-                (telegram_chat_id, max_chat_id, max_message_id),
-            ).fetchone()
-            if not row:
-                return None
-            return str(row[0])
-
-    def set_chat_route(
-        self,
-        *,
-        max_chat_title_norm: str,
-        telegram_chat_id: str,
-        telegram_chat_title: str | None = None,
-    ) -> None:
-        with closing(self._connect()) as conn:
-            conn.execute(
-                """
-                INSERT OR REPLACE INTO chat_routes (max_chat_title_norm, telegram_chat_id, telegram_chat_title)
-                VALUES (?, ?, ?)
-                """,
-                (max_chat_title_norm, telegram_chat_id, telegram_chat_title),
-            )
-            conn.commit()
-
-    def get_chat_route(self, *, max_chat_title_norm: str) -> str | None:
-        with closing(self._connect()) as conn:
-            row = conn.execute(
-                "SELECT telegram_chat_id FROM chat_routes WHERE max_chat_title_norm = ?",
-                (max_chat_title_norm,),
-            ).fetchone()
-            if not row:
-                return None
-            return str(row[0])

src/telegram_api.py

@@ -1,384 +0,0 @@
-import asyncio
-import json
-import os
-import pathlib
-import tempfile
-import urllib.parse
-from typing import Any
-
-import requests
-
-
-class TelegramApiError(RuntimeError):
-    def __init__(
-        self,
-        message: str,
-        *,
-        method: str | None = None,
-        status_code: int | None = None,
-        error_code: int | None = None,
-        description: str | None = None,
-        parameters: dict[str, Any] | None = None,
-    ) -> None:
-        super().__init__(message)
-        self.method = method
-        self.status_code = status_code
-        self.error_code = error_code
-        self.description = description
-        self.parameters = parameters or {}
-
-    @property
-    def migrate_to_chat_id(self) -> str | None:
-        value = self.parameters.get("migrate_to_chat_id")
-        if value is None:
-            return None
-        return str(value)
-
-
-class TelegramClient:
-    def __init__(self, bot_token: str, fallback_user_id: str, timeout: int = 30) -> None:
-        self._base_url = f"https://api.telegram.org/bot{bot_token}"
-        self._file_base_url = f"https://api.telegram.org/file/bot{bot_token}"
-        self._fallback_user_id = fallback_user_id
-        self._timeout = timeout
-        self._chat_title_to_id: dict[str, str] = {}
-        self._me: dict[str, Any] | None = None
-        self._tmp_root: str | None = None
-
-    @property
-    def fallback_user_id(self) -> str:
-        return str(self._fallback_user_id or "")
-
-    async def resolve_target_chat_id(self, max_chat_name: str) -> tuple[str, bool]:
-        chat_id = await self._find_chat_id_by_title(max_chat_name)
-        if chat_id:
-            return chat_id, True
-        return self._fallback_user_id, False
-
-    async def send_text(
-        self,
-        chat_id: str,
-        text: str,
-        *,
-        reply_to_message_id: int | None = None,
-    ) -> dict[str, Any]:
-        payload: dict[str, Any] = {
-            "chat_id": chat_id,
-            "text": text,
-            "disable_web_page_preview": True,
-        }
-        if reply_to_message_id is not None:
-            payload["reply_to_message_id"] = reply_to_message_id
-        return await self._request("sendMessage", payload)
-
-    async def send_photo(
-        self,
-        chat_id: str,
-        photo_url: str,
-        caption: str | None = None,
-        *,
-        reply_to_message_id: int | None = None,
-    ) -> dict[str, Any]:
-        payload: dict[str, Any] = {
-            "chat_id": chat_id,
-            "photo": photo_url,
-        }
-        if caption:
-            payload["caption"] = caption
-        if reply_to_message_id is not None:
-            payload["reply_to_message_id"] = reply_to_message_id
-        return await self._request("sendPhoto", payload)
-
-    async def send_video(
-        self,
-        chat_id: str,
-        video_url: str,
-        caption: str | None = None,
-        *,
-        reply_to_message_id: int | None = None,
-    ) -> dict[str, Any]:
-        payload: dict[str, Any] = {
-            "chat_id": chat_id,
-            "video": video_url,
-            "supports_streaming": True,
-        }
-        if caption:
-            payload["caption"] = caption
-        if reply_to_message_id is not None:
-            payload["reply_to_message_id"] = reply_to_message_id
-        return await self._request("sendVideo", payload)
-
-    async def send_document(
-        self,
-        chat_id: str,
-        document_url: str,
-        file_name: str | None = None,
-        caption: str | None = None,
-        *,
-        reply_to_message_id: int | None = None,
-    ) -> dict[str, Any]:
-        # Telegram часто не может скачать URL, которые доступны только клиенту MAX.
-        # Поэтому скачиваем сами во временный файл и отправляем как multipart upload.
-        safe_name = self._sanitize_filename(file_name) if file_name else None
-        tmp_path = await self._download_to_temp(document_url, preferred_filename=safe_name)
-        try:
-            return await self.send_document_file(
-                chat_id=chat_id,
-                file_path=tmp_path,
-                upload_filename=safe_name,
-                caption=caption,
-                reply_to_message_id=reply_to_message_id,
-            )
-        finally:
-            try:
-                os.remove(tmp_path)
-            except OSError:
-                pass
-
-    async def send_document_file(
-        self,
-        *,
-        chat_id: str,
-        file_path: str,
-        upload_filename: str | None = None,
-        caption: str | None = None,
-        reply_to_message_id: int | None = None,
-    ) -> dict[str, Any]:
-        payload: dict[str, Any] = {"chat_id": str(chat_id)}
-        if caption:
-            payload["caption"] = caption
-        if reply_to_message_id is not None:
-            payload["reply_to_message_id"] = str(int(reply_to_message_id))
-
-        filename = upload_filename or pathlib.Path(file_path).name
-
-        def _do_request() -> requests.Response:
-            with open(file_path, "rb") as f:
-                files = {"document": (filename, f)}
-                return requests.post(
-                    f"{self._base_url}/sendDocument",
-                    data=payload,
-                    files=files,
-                    timeout=self._timeout,
-                )
-
-        response = await asyncio.to_thread(_do_request)
-        return self._parse_response(method="sendDocument", response=response)
-
-    async def send_media_group(
-        self,
-        chat_id: str,
-        image_urls: list[str],
-        video_urls: list[str],
-        caption: str | None = None,
-        *,
-        reply_to_message_id: int | None = None,
-    ) -> list[dict[str, Any]]:
-        media: list[dict[str, Any]] = []
-
-        for url in image_urls:
-            media.append({"type": "photo", "media": url})
-
-        for url in video_urls:
-            media.append({"type": "video", "media": url, "supports_streaming": True})
-
-        if not media:
-            return []
-
-        if caption:
-            media[0]["caption"] = caption
-
-        mg_payload: dict[str, Any] = {
-            "chat_id": chat_id,
-            "media": media,
-        }
-        if reply_to_message_id is not None:
-            mg_payload["reply_to_message_id"] = reply_to_message_id
-        data = await self._request(
-            "sendMediaGroup",
-            mg_payload,
-        )
-        result = data.get("result", [])
-        if not isinstance(result, list):
-            return []
-        return [m for m in result if isinstance(m, dict)]
-
-    async def get_me(self) -> dict[str, Any]:
-        if self._me is not None:
-            return self._me
-        data = await self._request("getMe", {})
-        me = data.get("result")
-        if not isinstance(me, dict):
-            raise TelegramApiError(f"Telegram getMe: unexpected payload {data}")
-        self._me = me
-        return me
-
-    async def get_updates(self, *, offset: int | None, timeout: int = 25, limit: int = 100) -> list[dict[str, Any]]:
-        payload: dict[str, Any] = {
-            "timeout": timeout,
-            "limit": limit,
-            # Реагируем только на новые сообщения/посты (текст, фото, видео).
-            "allowed_updates": ["message", "channel_post"],
-        }
-        if offset is not None:
-            payload["offset"] = offset
-        data = await self._request("getUpdates", payload)
-        result = data.get("result", [])
-        if not isinstance(result, list):
-            return []
-        updates = [u for u in result if isinstance(u, dict)]
-        # Важно: не делаем getUpdates нигде больше (иначе 409 Conflict).
-        # Наполняем кэш чатов только из этого потока.
-        for upd in updates:
-            for container in ("message", "channel_post"):
-                msg = upd.get(container)
-                if not isinstance(msg, dict):
-                    continue
-                chat = msg.get("chat")
-                if not isinstance(chat, dict):
-                    continue
-                self._cache_chat(chat)
-        return updates
-
-    async def get_file_url(self, file_id: str) -> str:
-        data = await self._request("getFile", {"file_id": file_id})
-        result = data.get("result")
-        if not isinstance(result, dict):
-            raise TelegramApiError(f"Telegram getFile: unexpected payload {data}")
-        file_path = result.get("file_path")
-        if not isinstance(file_path, str) or not file_path.strip():
-            raise TelegramApiError(f"Telegram getFile: missing file_path {data}")
-        return f"{self._file_base_url}/{file_path}"
-
-    async def add_reaction(self, *, chat_id: str, message_id: str, emoji: str) -> None:
-        # setMessageReaction доступен не везде/не всегда; ошибки реакции не должны ломать бридж
-        await self._request(
-            "setMessageReaction",
-            {
-                "chat_id": chat_id,
-                "message_id": int(message_id),
-                "reaction": [{"type": "emoji", "emoji": emoji}],
-            },
-        )
-
-    def _cache_chat(self, chat: dict[str, Any]) -> None:
-        title_value = self._extract_chat_title(chat)
-        chat_id = chat.get("id")
-        if title_value and chat_id is not None:
-            self._chat_title_to_id[self._normalize_title(title_value)] = str(chat_id)
-
-    async def _find_chat_id_by_title(self, chat_title: str) -> str | None:
-        normalized = self._normalize_title(chat_title)
-        if not normalized:
-            return None
-
-        cached = self._chat_title_to_id.get(normalized)
-        if cached:
-            return cached
-        # Не дергаем getUpdates здесь — это вызовет конфликт с polling циклом.
-        return None
-
-    @staticmethod
-    def _extract_chat_title(chat: dict[str, Any]) -> str:
-        return str(chat.get("title") or chat.get("username") or "").strip()
-
-    @staticmethod
-    def _normalize_title(value: str) -> str:
-        return value.strip().casefold()
-
-    async def _request(self, method: str, payload: dict[str, Any]) -> dict[str, Any]:
-        url = f"{self._base_url}/{method}"
-
-        def _do_request() -> requests.Response:
-            return requests.post(url, json=payload, timeout=self._timeout)
-
-        response = await asyncio.to_thread(_do_request)
-        return self._parse_response(method=method, response=response)
-
-    def _parse_response(self, *, method: str, response: requests.Response) -> dict[str, Any]:
-        if response.status_code >= 400:
-            error_code: int | None = None
-            description: str | None = None
-            parameters: dict[str, Any] = {}
-            try:
-                payload_data = response.json()
-                if isinstance(payload_data, dict):
-                    if isinstance(payload_data.get("error_code"), int):
-                        error_code = payload_data.get("error_code")
-                    if isinstance(payload_data.get("description"), str):
-                        description = payload_data.get("description")
-                    if isinstance(payload_data.get("parameters"), dict):
-                        parameters = payload_data.get("parameters", {})
-            except (json.JSONDecodeError, ValueError):
-                payload_data = None
-
-            raise TelegramApiError(
-                f"Telegram HTTP error on {method}: {response.status_code} {response.text}",
-                method=method,
-                status_code=response.status_code,
-                error_code=error_code,
-                description=description,
-                parameters=parameters,
-            )
-        data = response.json()
-        if not data.get("ok"):
-            raise TelegramApiError(
-                f"Telegram API error on {method}: {data}",
-                method=method,
-                error_code=data.get("error_code") if isinstance(data.get("error_code"), int) else None,
-                description=data.get("description") if isinstance(data.get("description"), str) else None,
-                parameters=data.get("parameters") if isinstance(data.get("parameters"), dict) else None,
-            )
-        return data
-
-    async def _download_to_temp(self, url: str, preferred_filename: str | None = None) -> str:
-        filename = preferred_filename or self._infer_filename_from_url(url) or "max-file"
-        tmp_dir = self._ensure_tmp_root()
-        fd, path = tempfile.mkstemp(prefix="max2tg_", suffix=f"_{filename}", dir=tmp_dir)
-        os.close(fd)
-
-        def _do_download() -> None:
-            with requests.get(url, stream=True, timeout=self._timeout) as r:
-                r.raise_for_status()
-                with open(path, "wb") as f:
-                    for chunk in r.iter_content(chunk_size=1024 * 256):
-                        if chunk:
-                            f.write(chunk)
-
-        try:
-            await asyncio.to_thread(_do_download)
-            return path
-        except Exception:
-            try:
-                os.remove(path)
-            except OSError:
-                pass
-            raise
-
-    def _ensure_tmp_root(self) -> str:
-        if self._tmp_root and os.path.isdir(self._tmp_root):
-            return self._tmp_root
-        self._tmp_root = tempfile.mkdtemp(prefix="max2tg_")
-        return self._tmp_root
-
-    @staticmethod
-    def _infer_filename_from_url(url: str) -> str | None:
-        try:
-            parsed = urllib.parse.urlparse(url)
-            name = pathlib.Path(parsed.path).name
-            if name and name not in {"/", ".", ".."}:
-                # Windows-safe filename (и вообще безопаснее для FS).
-                bad = '<>:"/\\|?*'
-                cleaned = "".join("_" if ch in bad else ch for ch in name).strip().strip(".")
-                return cleaned or None
-        except Exception:
-            return None
-        return None
-
-    @staticmethod
-    def _sanitize_filename(name: str | None) -> str | None:
-        if not name:
-            return None
-        bad = '<>:"/\\|?*'
-        cleaned = "".join("_" if ch in bad else ch for ch in str(name)).strip().strip(".")
-        return cleaned or None

src/telegram_max_commands.py

@@ -1,285 +0,0 @@
-import logging
-from typing import Any
-
-from pymax import MaxClient
-
-from telegram_api import TelegramClient
-
-logger = logging.getLogger(__name__)
-
-
-def _is_private_chat(message: dict[str, Any]) -> bool:
-    chat = message.get("chat")
-    if not isinstance(chat, dict):
-        return False
-    return str(chat.get("type") or "").strip().casefold() == "private"
-
-
-def _sender_id(message: dict[str, Any]) -> str:
-    sender = message.get("from")
-    if not isinstance(sender, dict):
-        return ""
-    return str(sender.get("id") or "")
-
-
-def _chat_id(message: dict[str, Any]) -> str:
-    chat = message.get("chat")
-    if not isinstance(chat, dict):
-        return ""
-    return str(chat.get("id") or "")
-
-
-def _infer_max_chat_type(chat_obj: Any) -> str:
-    """
-    Возвращает один из: direct / группа / канал
-    Best-effort: структура объектов pymax может отличаться между версиями.
-    """
-    # 1) Явные признаки по полям.
-    for name in ("type", "chat_type", "kind"):
-        value = getattr(chat_obj, name, None)
-        if value is None:
-            continue
-        v = str(value).strip().casefold()
-        # PyMax часто использует enum-ы вида ChatType.CHANNEL, поэтому проверяем и точные значения, и подстроки.
-        if v in {"channel", "канал"} or "channel" in v or "канал" in v:
-            return "канал"
-        if v in {"group", "supergroup", "группа"} or "group" in v or "груп" in v:
-            return "группа"
-        if v in {"direct", "dm", "private"} or "direct" in v or "private" in v or "dm" == v:
-            return "direct"
-
-    # 2) Флаги.
-    for true_names, mapped in (
-        (("is_channel", "channel"), "канал"),
-        (("is_group", "group"), "группа"),
-        (("is_direct", "direct"), "direct"),
-    ):
-        for n in true_names:
-            try:
-                if getattr(chat_obj, n, False) is True:
-                    return mapped
-            except Exception:
-                continue
-
-    # 3) Эвристика по количеству участников.
-    for n in ("members_count", "participants", "participants_count", "member_count"):
-        try:
-            value = getattr(chat_obj, n, None)
-        except Exception:
-            value = None
-        if isinstance(value, int):
-            return "группа" if value > 2 else "direct"
-
-    return "direct"
-
-
-def _max_chat_title(chat_obj: Any) -> str:
-    for n in ("title", "name", "chat_title"):
-        try:
-            value = getattr(chat_obj, n, None)
-        except Exception:
-            value = None
-        if isinstance(value, str) and value.strip():
-            return value.strip()
-    # запасной вариант
-    cid = getattr(chat_obj, "id", None)
-    return f"chat {cid}" if cid is not None else "chat"
-
-
-def _normalize(value: str) -> str:
-    return str(value or "").strip().casefold()
-
-
-def _deduplicate_chats(chats: list[Any]) -> list[Any]:
-    """
-    Возвращает уникальные чаты с сохранением исходного порядка.
-    Сначала пытаемся уникализировать по chat.id, затем по нормализованному title.
-    """
-    unique: list[Any] = []
-    seen_ids: set[str] = set()
-    seen_titles: set[str] = set()
-
-    for chat in chats:
-        chat_id = getattr(chat, "id", None)
-        if chat_id is not None:
-            key_id = str(chat_id).strip()
-            if key_id in seen_ids:
-                continue
-            seen_ids.add(key_id)
-            unique.append(chat)
-            continue
-
-        key_title = _normalize(_max_chat_title(chat))
-        if not key_title:
-            unique.append(chat)
-            continue
-        if key_title in seen_titles:
-            continue
-        seen_titles.add(key_title)
-        unique.append(chat)
-
-    return unique
-
-
-async def _refresh_chats_best_effort(max_client: MaxClient) -> None:
-    # group.py: fetch_chats(marker=None) заполняет max_client.chats
-    try:
-        fetch = getattr(max_client, "fetch_chats", None)
-        if fetch is not None:
-            await fetch()
-    except Exception:
-        logger.debug("MAX fetch_chats failed (non-fatal)", exc_info=True)
-
-
-def _find_chat_by_title(max_client: MaxClient, title: str) -> Any | None:
-    wanted = _normalize(title)
-    if not wanted:
-        return None
-    chats = _deduplicate_chats(list(getattr(max_client, "chats", []) or []))
-    for c in chats:
-        if _normalize(_max_chat_title(c)) == wanted:
-            return c
-    return None
-
-
-async def _join_by_link(max_client: MaxClient, link: str) -> str:
-    """
-    PyMax: вступление в группу по ссылке — join_group(link).
-    См. исходники: https://github.com/MaxApiTeam/PyMax/blob/041dedeb9f9461b3360e2881a8a18a767de74871/src/pymax/mixins/group.py#L260
-    """
-    method = getattr(max_client, "join_group", None)
-    if method is None:
-        return "Не смог присоединиться: у клиента MAX нет метода join_group(link)."
-
-    try:
-        await method(link)
-        return "Ок: вступил по ссылке."
-    except Exception as e:
-        logger.exception("MAX join_group failed")
-        return f"Ошибка при присоединении: {e}"
-
-
-async def handle_control_command(
-    message: dict[str, Any],
-    *,
-    max_client: MaxClient,
-    telegram: TelegramClient,
-) -> str | None:
-    """
-    Возвращает текст ответа, если команда обработана.
-    Если None — не команда/не наш случай.
-    """
-    text = str(message.get("text") or "").strip()
-    if not text.startswith("/"):
-        return None
-
-    if not _is_private_chat(message):
-        return None
-
-    if _sender_id(message) != str(telegram.fallback_user_id):
-        return None
-
-    cmd, *rest = text.split(maxsplit=1)
-    cmd = cmd.split("@", 1)[0].strip().casefold()
-    arg = rest[0].strip() if rest else ""
-
-    if cmd == "/help":
-        return (
-            "Команды управления MAX (только для fallback_user_id в личке):\n"
-            "/help — справка\n"
-            "/list — список активных чатов MAX\n"
-            "/join <LINK> — присоединиться к группе/каналу по ссылке\n"
-            "/leave <НАЗВАНИЕ> — покинуть указанный канал\n"
-            "/last_messages <НАЗВАНИЕ> — последние 10 сообщений из канала\n"
-            "/bind_max <НАЗВАНИЕ> — привязать текущий Telegram-чат к чату MAX"
-        )
-
-    if cmd == "/list":
-        await _refresh_chats_best_effort(max_client)
-
-        chats = _deduplicate_chats(list(getattr(max_client, "chats", []) or []))
-        if not chats:
-            return "Список чатов пуст (или клиент MAX ещё не успел их загрузить)."
-
-        lines: list[str] = []
-        for c in chats:
-            title = _max_chat_title(c)
-            ctype = _infer_max_chat_type(c)
-            lines.append(f"- {title} ({ctype})")
-        return "Активные чаты MAX:\n" + "\n".join(lines)
-
-    if cmd == "/join":
-        if not arg:
-            return "Использование: /join <LINK>"
-        return await _join_by_link(max_client, arg)
-
-    if cmd == "/leave":
-        if not arg:
-            return "Использование: /leave <НАЗВАНИЕ>"
-
-        await _refresh_chats_best_effort(max_client)
-        chat = _find_chat_by_title(max_client, arg)
-        if chat is None:
-            return f"Чат/канал не найден в активных: {arg}"
-
-        chat_id = getattr(chat, "id", None)
-        if chat_id is None:
-            return "Не смог определить id чата."
-
-        ctype = _infer_max_chat_type(chat)
-        if ctype != "канал":
-            return f"'{_max_chat_title(chat)}' — это не канал (тип: {ctype})."
-
-        method = getattr(max_client, "leave_channel", None)
-        if method is None:
-            return "У клиента MAX нет метода leave_channel(chat_id)."
-
-        try:
-            await method(int(chat_id))
-            return f"Ок: покинул канал '{_max_chat_title(chat)}'."
-        except Exception as e:
-            logger.exception("MAX leave_channel failed")
-            return f"Ошибка при выходе: {e}"
-
-    if cmd == "/last_messages":
-        if not arg:
-            return "Использование: /last_messages <НАЗВАНИЕ>"
-
-        await _refresh_chats_best_effort(max_client)
-        chat = _find_chat_by_title(max_client, arg)
-        if chat is None:
-            return f"Канал не найден в активных: {arg}"
-
-        chat_id = getattr(chat, "id", None)
-        if chat_id is None:
-            return "Не смог определить id канала."
-
-        try:
-            # PyMax: MessageMixin.fetch_history(chat_id, from_time=None, forward=0, backward=200)
-            # https://github.com/MaxApiTeam/PyMax/blob/041dedeb9f9461b3360e2881a8a18a767de74871/src/pymax/mixins/message.py#L594
-            history = await max_client.fetch_history(chat_id=int(chat_id), forward=0, backward=10)
-        except AttributeError:
-            return "У клиента MAX нет метода fetch_history(chat_id, from_time=None, forward=0, backward=200)."
-        except Exception as e:
-            logger.exception("MAX fetch_history failed")
-            return f"Ошибка при получении истории: {e}"
-
-        messages = list(history or [])
-        if not messages:
-            return f"В канале '{_max_chat_title(chat)}' нет сообщений (или история недоступна)."
-
-        lines: list[str] = []
-        for m in messages[:10]:
-            text_value = str(getattr(m, "text", "") or "").strip()
-            mid = getattr(m, "id", None)
-            if text_value:
-                lines.append(f"- {mid}: {text_value}")
-            else:
-                lines.append(f"- {mid}: <без текста>")
-        return f"Последние сообщения из '{_max_chat_title(chat)}':\n" + "\n".join(lines)
-
-    return (
-        "Неизвестная команда.\n"
-        "Набери /help чтобы увидеть доступные команды."
-    )
-

tech-specs.md

@@ -1,475 +1,262 @@
-# Техническое задание: двунаправленный мост MAX <-> Telegram
+# Техническая спецификация: max2telegram (v3.2)
-
+
-## 1. Назначение системы
+## 1. Назначение продукта
-
+
-Система должна обеспечивать непрерывную двунаправленную синхронизацию сообщений между мессенджером MAX и Telegram:
+**max2telegram** — асинхронный сервис-мост для двусторонней синхронизации переписки между мессенджером **MAX** и **Telegram**. Сторона Telegram представлена **одним Форум-каналом** с множеством тематических топиков. 
-
+
-- направление A: входящие сообщения из MAX пересылаются в Telegram;
+Сервис использует **WebSocket-подключение** к API MAX для мгновенного получения событий и хранит **маркеры (курсоры) последнего обработанного сообщения** в базе данных. Это гарантирует, что ни одно сообщение не будет потеряно или обработано дважды во время перезапуска сервиса, сетевых сбоев или даунтайма. Вся маршрутизация выполняется **строго по идентификаторам**, а отправка в обе стороны регулируется асинхронными Redis-очередями для соблюдения лимитов API.
-- направление B: входящие сообщения из Telegram пересылаются в MAX;
+
-- поддерживаются текст, фото, видео, документы/файлы и ответы (reply) в пределах доступных API;
+---
-- реализованы дедупликация, хранение связей между сообщениями в обоих направлениях и базовый health-monitoring;
+
-- предусмотрен fallback-маршрут в Telegram при отсутствии явного соответствия чатов.
+## 2. Участники и роли
-
+
-Система реализуется как один сервисный процесс (или контейнер), работающий постоянно.
+| Участник | Роль в системе |
-
+|----------|----------------|
-## 2. Контекст и границы
+| **Аккаунт MAX** | Источник и приёмник сообщений в MAX (групповые чаты и личные диалоги). |
-
+| **Telegram-бот** | Администратор Форум-канала; создаёт топики, читает сообщения по `thread_id`, ставит реакции, выполняет команды. |
-### 2.1 Внешние зависимости
+| **Доверенный оператор (fallback)** | Получает системные уведомления об ошибках очередей; выполняет управляющие команды. **В части пересылки сообщений имеет те же права, что и любой другой участник форума.** |
-
+| **Участники форума Telegram** | Могут писать в любые маппированные топики; все их сообщения асинхронно пересылаются в MAX. |
-Обязательные внешние системы:
+| **Оператор инфраструктуры** | Настраивает Docker Compose, управляет переменными окружения, уровнем логирования и контролирует логи. |
-
+
-- API MAX (через клиентскую библиотеку или собственный API-клиент);
+---
-- Telegram Bot API (через клиентскую библиотеку);
+
-- SQLite (или совместимое хранилище) для локального состояния;
+## 3. Архитектура и потоки данных
-- переменные окружения для конфигурации.
+
-
+### 3.1. Общая схема
-### 2.2 Что входит в систему
+```mermaid
-
+flowchart LR
-- запуск и аутентификация клиента MAX;
+    subgraph MAX["MAX API (WebSocket)"]
-- polling Telegram `getUpdates` (без webhook);
+        MC[Чаты и ЛС MAX]
-- обработка входящих событий в обоих направлениях;
+    end
-- маршрутизация по названию чата и по явным биндам;
+
-- хранение mapping/дедупликации/маршрутов;
+    subgraph Bridge["max2telegram (Python App)"]
-- HTTP health endpoints (`/livez`, `/healthz`).
+        WS_LAYER[Слой клиента MAX]
-
+        TG_LAYER[Слой клиента Telegram]
-### 2.3 Что НЕ входит в систему
+        ROUTER[Слой маршрутизации]
-
+        STATE[(Слой состояния: маркеры в SQLite)]
-- UI/панель администрирования;
+        MAP[(Слой маппинга: ID в SQLite)]
-- сложная очередь сообщений (Kafka/RabbitMQ и т.п.);
+        QUEUE[(Слой очередей: Redis)]
-- гарантированная exactly-once доставка между платформами;
+    end
-- миграции БД с версионированием (в базовой реализации только `CREATE TABLE IF NOT EXISTS`);
+
-- хранение медиа в собственной файловой инфраструктуре.
+    subgraph TG["Telegram Bot API"]
-
+        FC[Форум-канал]
-## 3. Функциональные требования
+        TOPICS[Топики]
-
+        FB[Личка fallback]
-## 3.1 MAX -> Telegram
+    end
-
+
-При получении сообщения из MAX система должна:
+    MC <-->|WS Stream| WS_LAYER
-
+    WS_LAYER <--> STATE
-1. Распарсить сообщение:
+    WS_LAYER --> ROUTER
-   - `message_id`, `chat_id`, `sender_name`, `chat_name`, текст;
+    ROUTER <--> MAP
-   - список `image_urls`, `video_urls`, `file_urls`;
+    ROUTER --> QUEUE
-   - список неизвестных вложений;
+    QUEUE --> TG_LAYER
-   - данные reply-контекста (`reply_to_max_message_id`, preview).
+    TG_LAYER --> FC
-2. Обогатить данные через API MAX (best effort):
+    
-   - попытаться получить человекочитаемое имя отправителя;
+    FC --> TG_LAYER --> ROUTER
-   - попытаться получить реальное название чата;
+    ROUTER --> QUEUE
-   - извлечь дополнительные вложения через типизированные attach-объекты.
+    QUEUE --> WS_LAYER
-3. Проверить дедупликацию по паре `(message_id, chat_id)`; дубликаты не отправлять.
+    WS_LAYER --> MC
-4. Выбрать Telegram-чат:
+    
-   - сначала через явный route (bind) по нормализованному названию MAX-чата;
+    FB <--> TG_LAYER
-   - затем через кэш чатов Telegram по совпадению заголовка;
+```
-   - если не найдено — отправка в `fallback_user_id`.
+
-5. Сформировать текст:
+### 3.2. Поток «MAX → Telegram» (с маркерами и очередью)
-   - если целевой Telegram-чат найден (не fallback): `"{sender}:\n{text}"`;
+1. `Слой клиента MAX` подключается по WebSocket, запрашивает последние маркеры из `Слоя состояния`.
-   - если fallback: `"{sender} / {chat}:\n{text}"`;
+2. При получении нового события:
-   - при неизвестных вложениях добавить уведомление в конец.
+   - **Дедупликация:** если `message_id` <= `last_message_id`, событие игнорируется.
-6. Обработать reply:
+   - `Слой маршрутизации` проверяет маппинг в `Слое маппинга`. Если нет – запрашивает у `Слоя клиента Telegram` создание топика, сохраняет маппинг.
-   - попытаться найти Telegram `reply_to_message_id` через mapping;
+   - Задача сериализуется и передается в `Слой очередей` (`max2tg_queue`).
-   - не дублировать вложения из исходного сообщения, на которое отвечают;
+   - **Маркер** атомарно обновляется в `Слое состояния`.
-   - если mapping не найден — добавить текстовый контекст ответа.
+3. `Слой клиента Telegram` (Воркер) забирает задачу, соблюдает лимит (≥ 3.5 сек), отправляет сообщение и сохраняет связь `max_message_id` ↔ `tg_message_id` в БД.
-7. Отправить контент:
+
-   - при `image+video > 1` — отправить единым альбомом (`sendMediaGroup`);
+### 3.3. Поток «Telegram → MAX» (с очередью)
-   - иначе отправить текст/медиа/файлы поштучно;
+1. `Слой клиента Telegram` получает сообщение из топика (`tg_chat_id` + `message_thread_id`). Игнорирует сообщения бота.
-   - при полностью пустом payload отправить служебный fallback-текст.
+2. `Слой маршрутизации` ищет пару `{tg_chat_id, message_thread_id}` в `Слое маппинга`.
-8. Сохранить mapping отправленных сообщений.
+3. Если найдено: задача передается в `Слой очередей` (`tg2max_queue`). Если нет: игнорируется.
-9. Пометить сообщение как forwarded.
+4. `Слой клиента MAX` (Воркер) забирает задачу, ждет настраиваемого лимита, отправляет сообщение в MAX.
-10. При ошибке основного пути сделать аварийное best-effort уведомление в fallback-чат Telegram.
+5. **Только после успеха от API MAX**, `Слой клиента Telegram` ставит реакцию 🦄 на исходное сообщение.
-
+
-## 3.2 Telegram -> MAX
+---
-
+
-Система должна запускать единственный polling-цикл `getUpdates` и:
+## 4. Технические требования и стек технологий
-
+
-1. При старте получить `bot_id` через `getMe`.
+### 4.1. Стек разработки
-2. Обновить локальный кэш чатов MAX (`title -> id`) на основе доступного списка.
+| Компонент | Технология | Обоснование / Требования |
-3. В цикле получать updates с `offset` и `allowed_updates=["message","channel_post"]`.
+|-----------|------------|--------------------------|
-4. Для каждого сообщения:
+| **Язык** | Python 3.10+ | Нативная поддержка `asyncio`, строгая типизация (type hints). |
-   - отбросить неподдерживаемые типы;
+| **Клиент MAX** | `PyMAX` | **Обязательная поддержка WebSocket** для стриминга событий. Должен поддерживать переподключение и запрос истории по курсору/ID. |
-   - отбросить сообщения бота (защита от петель);
+| **Клиент Telegram** | `aiogram 3.x` | Предпочтительно для Bot API (работа с форумами, очередями, поллингом/вебхуками). |
-   - обработать команду `/bind_max` в приоритетном порядке;
+| **База данных** | SQLite | Хранение маппингов и маркеров состояния. **Обязательно**: режим `PRAGMA journal_mode=WAL` и `PRAGMA synchronous=NORMAL`. Библиотека: `aiosqlite` или `SQLAlchemy` (async). |
-   - обработать служебные команды управления MAX (только личка + только fallback user);
+| **Очереди** | Redis | Хранение очередей `max2tg_queue` и `tg2max_queue`. Персистентность через `appendonly yes` (AOF). Библиотека: `redis-py` (async). |
-   - для обычных сообщений найти чат MAX по нормализованному названию Telegram-чата;
+| **Логирование** | `structlog` / `logging` | Структурированные JSON-логи. Уровень логирования настраивается через переменную окружения. |
-   - если чат MAX не найден — не пересылать, логировать ошибку.
+
-5. Обработать `media_group_id`:
+### 4.2. Архитектура приложения (Python)
-   - буферизовать элементы альбома по ключу `(telegram_chat_id, media_group_id)`;
+Приложение строится на базе `asyncio` и состоит из следующих независимых задач (tasks):
-   - после grace-паузы (около 1.2 сек) отправить одним сообщением в MAX с несколькими вложениями.
+1. **MAX WebSocket Listener**: Поддерживает соединение, парсит события, управляет маркерами.
-6. Для одиночных сообщений:
+2. **Telegram Listener**: Aiogram Dispatcher.
-   - сформировать текст `"{sender}:\n{text_or_caption}"`;
+3. **TG Worker**: Цикл `BLPOP` из `max2tg_queue` с `asyncio.sleep(3.5)`.
-   - для фото/видео получить URL через `getFile` и вложить в MAX как native media attach;
+4. **MAX Worker**: Цикл `BLPOP` из `tg2max_queue` с настраиваемой задержкой.
-   - для document/audio/voice/animation/sticker/video_note добавить URL-список в текстовый блок;
+5. **Admin Handler**: Обработчик команд только от `FALLBACK_USER_ID`.
-   - при reply попытаться найти соответствующее сообщение MAX через mapping.
+
-7. После успешной отправки:
+### 4.3. Требования к развертыванию (Docker + Docker Compose)
-   - поставить реакцию на Telegram-сообщение (emoji, best effort);
+Сервис поставляется в виде готового к запуску окружения. Папка `./data` монтируется для сохранения SQLite БД и сессии PyMAX между перезапусками.
-   - сохранить mapping `(telegram chat/message -> max chat/message)`.
+
-
+```yaml
-## 3.3 Управляющие команды в Telegram
+version: '3.8'
-
+services:
-Команды обрабатываются только в приватном чате с ботом и только от пользователя `fallback_user_id`, кроме `/bind_max` (она может работать в целевом чате).
+  redis:
-
+    image: redis:7-alpine
-Поддерживаемые команды:
+    restart: always
-
+    volumes:
-- `/help` — список команд;
+      - redis_data:/data
-- `/list` — список активных чатов MAX;
+    command: redis-server --appendonly yes
-- `/join <LINK>` — вступление в группу/канал MAX по ссылке;
+
-- `/leave <НАЗВАНИЕ>` — выход из канала MAX (только если тип чата определен как канал);
+  app:
-- `/last_messages <НАЗВАНИЕ>` — последние 10 сообщений;
+    build: .
-- `/bind_max <точное название MAX-чата>` — привязка текущего Telegram-чата к MAX-чату.
+    restart: always
-
+    depends_on:
-Требования:
+      - redis
-
+    environment:
-- у команд должны быть понятные текстовые ответы;
+      - MAX_TOKEN=${MAX_TOKEN}
-- ошибки внешних API должны возвращаться в ответе, не падая процессом;
+      - MAX_DEVICE_ID=${MAX_DEVICE_ID}
-- `/bind_max` должна валидировать существование MAX-чата перед сохранением маршрута.
+      - TG_BOT_TOKEN=${TG_BOT_TOKEN}
-
+      - TG_FORUM_CHANNEL_ID=${TG_FORUM_CHANNEL_ID}
-## 4. Нефункциональные требования
+      - FALLBACK_USER_ID=${FALLBACK_USER_ID}
-
+      - DATABASE_URL=sqlite+aiosqlite:///app/data/bridge.db
-- **Надежность:** сервис работает бесконечно, при ошибках polling применяет backoff.
+      - REDIS_URL=redis://redis:6379/0
-- **Идемпотентность (частичная):** дедупликация MAX->Telegram через БД.
+      - TG_RATE_LIMIT_DELAY_SEC=3.5
-- **Наблюдаемость:** структурированные логи и health endpoint.
+      - MAX_RATE_LIMIT_DELAY_SEC=1.0
-- **Портируемость:** реализация возможна на любом языке при соблюдении контрактов.
+      - MAX_RECONNECT_FETCH_LIMIT=50
-- **Производительность:** обработка событий в near real-time, без тяжелых batch-процессов.
+      - LOG_LEVEL=INFO
-- **Отказоустойчивость:** best-effort при частичных отказах API/медиа.
+    volumes:
-
+      - ./data:/app/data
-## 5. Конфигурация (env contract)
+    logging:
-
+      driver: "json-file"
-Обязательные параметры:
+      options:
-
+        max-size: "10m"
-- `MAX_PHONE` — телефон аккаунта MAX (для авторизации/сессии);
+        max-file: "3"
-- `MAX_WORK_DIR` — рабочая директория клиента MAX (по умолчанию `cache`);
+
-- `TELEGRAM_BOT_TOKEN` — токен Telegram-бота;
+volumes:
-- `TELEGRAM_FALLBACK_USER_ID` — Telegram user/chat id для fallback;
+  redis_data:
-- `SQLITE_PATH` — путь до SQLite БД (по умолчанию `${MAX_WORK_DIR}/max2telegram.db`).
+```
-
+
-Дополнительно:
+### 4.4. Архитектурные принципы и стандарты разработки
-
+Проект обязан строго следовать следующим инженерным стандартам:
-- `TZ` — таймзона окружения;
+
-- `PYTHONUNBUFFERED` (или аналог) — политика буферизации логов.
+1. **Строгое разделение слоёв (Layered Architecture)**:
-
+   - `MAX Layer` отвечает **только** за взаимодействие с API MAX (подключение WS, отправка/получение сообщений, сессия).
-Валидация:
+   - `Telegram Layer` отвечает **только** за взаимодействие с Telegram Bot API (получение обновлений, отправка в топики, реакции, обработка команд).
-
+   - `Router Layer` отвечает **только** за логику сопоставления идентификаторов и принятие решений о маршруте.
-- обязательные переменные должны проверяться при старте;
+   - `Queue Layer` отвечает **только** за сериализацию, буферизацию и доставку задач между слоями.
-- при отсутствии обязательной переменной процесс завершает запуск с явной ошибкой.
+   - `Storage Layer` отвечает **только** за атомарные операции чтения/записи в SQLite/Redis.
-
+   - **Запрещено**: вызывать методы одного слоя из другого напрямую. Например, `MAX Layer` не может ставить реакции или создавать топики в Telegram. Вся межслойная коммуникация проходит через интерфейсы абстракций и очереди.
-## 6. Архитектура
+
-
+2. **SOLID**:
-### 6.1 Компоненты
+   - **S**ingle Responsibility: Каждый модуль/класс выполняет одну четкую задачу.
-
+   - **O**pen/Closed: Расширение функционала (новые типы медиа, новые команды) происходит без модификации стабильного кода ядерных компонентов.
-1. **Bootstrap / Main**
+   - **L**iskov Substitution & **I**nterface Segregation: Чёткие контракты между слоями, минимум методов в интерфейсах.
-   - загружает конфиг;
+   - **D**ependency Inversion: Слои зависят от абстракций (протоколов/интерфейсов), а не от конкретных реализаций клиентов.
-   - создает клиентов MAX и Telegram;
+
-   - инициализирует storage;
+3. **KISS**:
-   - запускает health server;
+   - Избегать избыточной абстракции и "over-engineering".
-   - подключает обработчики входящих сообщений MAX;
+   - Использовать стандартные паттерны `asyncio`, `aiogram` и `redis-py`.
-   - запускает Telegram->MAX poller как фоновую задачу.
+   - Конфигурация, бизнес-логика и инфраструктурный код должны быть явно разделены, но не размазаны по сотне файлов.
-
+
-2. **MAX->Telegram Bridge**
+---
-   - парсинг + enrich входящих MAX-сообщений;
+
-   - маршрутизация в Telegram;
+## 5. Бизнес-функции и правила
-   - отправка текст/медиа/документы;
+
-   - обработка миграции Telegram chat id;
+### 5.1. Двусторонняя пересылка и очереди
-   - сохранение mapping и dedup.
+- **Гарантированная доставка**: Сообщения не теряются при перезапуске контейнера благодаря персистентным Redis-очередям.
-
+- **Rate Limiting**: В Telegram ≥ 3.5 сек, в MAX — настраиваемая задержка.
-3. **Telegram API Client**
+- **Подтверждение**: Реакция 🦄 ставится **только после** успешного подтверждения отправки из очереди в MAX.
-   - HTTP-обертка над Bot API;
+
-   - методы отправки всех типов контента;
+### 5.2. Маршрутизация и управление топиками
-   - `getUpdates` + кэширование известных чатов;
+- **Строгое сопоставление по ID**: Ключ поиска: `max_chat_id` ↔ `{tg_chat_id, tg_thread_id}`.
-   - `getFile` для медиа URL;
+- **Автоматическое создание**: При отсутствии маппинга создается топик. Имя: `"Название чата"` или `"👤 Имя контакта"`. Имя хранится только для UX (`/list`).
-   - унифицированная модель ошибок с извлечением `migrate_to_chat_id`.
+- **Игнорирование**: Сообщения из TG-топиков без маппинга игнорируются.
-
+
-4. **Telegram->MAX Bridge**
+### 5.3. Формат сообщений и контент
-   - polling updates;
+- **MAX → TG**: В групповых топиках: `<Имя отправителя>:\n<текст>`. В ЛС-топиках: только текст.
-   - фильтрация собственных сообщений;
+- **TG → MAX**: Всегда: `<Имя Фамилия> (@username):\n<текст>`.
-   - обработка команд;
+- **Медиа**: Фото, видео, альбомы, файлы поддерживаются нативно. Ненативные типы передаются ссылками `[Telegram files]`.
-   - преобразование Telegram payload -> MAX message/attachments;
+- **Треды**: Поддерживаются через `max_message_id` ↔ `tg_message_id` в БД.
-   - буферизация media group;
+
-   - реакция и mapping.
+### 5.4. Управление и команды
-
+Команды обрабатываются **исключительно** в личной переписке с ботом и **только** от `FALLBACK_USER_ID`. В части пересылки сообщений все участники форума равны.
-5. **Parser MAX Message**
+
-   - универсальный best-effort разбор разнородных форматов вложений;
+| Команда | Действие |
-   - классификация URL по типам;
+|---------|----------|
-   - извлечение reply-контекста.
+| `/start` | Приветствие, краткая справка, проверка статуса подключения |
-
+| `/help` | Полная справка по доступным командам управления |
-6. **Storage**
+| `/list` | Список активных маппингов (ID, названия, статус) |
-   - таблица дедупликации;
+| `/join <ссылка>` | Вступление в MAX-группу или канал |
-   - таблица двустороннего mapping;
+| `/leave <id или название>` | Выход из указанного MAX-канала |
-   - таблица явных маршрутов (binds).
+| `/last_messages <id или название>` | Последние 10 сообщений из MAX-чата или ЛС |
-
+
-7. **Health subsystem**
+### 5.5. Надежность и восстановление (WebSocket и маркеры)
-   - хранит отметки времени последнего успеха/ошибки по MAX и Telegram;
+1. **Хранение маркеров**: Таблица `sync_markers` в SQLite хранит `last_processed_message_id` для каждого чата.
-   - формирует snapshot;
+2. **Идемпотентность**: События с `message_id` <= маркера отбрасываются.
-   - HTTP endpoint отдает liveness/readiness.
+3. **Восстановление после даунтайма**: При старте читаются маркеры, запрашивается история (до `MAX_RECONNECT_FETCH_LIMIT`), сообщения ставятся в очередь.
-
+4. **Атомарность**: Маркер обновляется только после успешной постановки в Redis.
-8. **Auth utility**
+
-   - отдельный скрипт первичной авторизации MAX;
+---
-   - сохраняет сессию в рабочем каталоге.
+
-
+## 6. Конфигурация (Переменные окружения)
-### 6.2 Логическая схема взаимодействия
+
-
+| Переменная | Описание | Пример / Значение по умолчанию |
-- MAX event -> Parser -> MAX->TG Bridge -> Telegram API -> Storage update.
+|------------|----------|--------------------------------|
-- Telegram update -> TG->MAX Bridge -> MAX API -> Storage update.
+| `MAX_TOKEN` | Токен авторизации аккаунта MAX | `eyJhbGci...` |
-- TG->MAX Bridge единолично вызывает `getUpdates`, одновременно наполняя кэш чатов Telegram.
+| `MAX_DEVICE_ID` | Уникальный идентификатор устройства/сессии | `a1b2c3d4...` |
-- Storage используется обоими мостами как разделяемый слой состояния.
+| `TG_BOT_TOKEN` | Токен Telegram-бота от @BotFather | `123456:ABC-DEF1234...` |
-- Health обновляется из polling-циклов и MAX событий.
+| `TG_FORUM_CHANNEL_ID` | ID Форум-канала (строго с `-100`) | `-1001234567890` |
-
+| `FALLBACK_USER_ID` | Telegram ID администратора | `987654321` |
-## 7. Модель данных и БД
+| `DATABASE_URL` | Строка подключения к SQLite | `sqlite+aiosqlite:///app/data/bridge.db` |
-
+| `REDIS_URL` | Строка подключения к Redis | `redis://redis:6379/0` |
-Используется SQLite (или эквивалент в другой СУБД).
+| `TG_RATE_LIMIT_DELAY_SEC` | Задержка между отправками в TG | `3.5` |
-
+| `MAX_RATE_LIMIT_DELAY_SEC` | Задержка между отправками в MAX | `1.0` |
-### 7.1 Таблица `forwarded_messages`
+| `LS_TOPIC_PREFIX` | Префикс для именования ЛС-топиков | `👤 ` |
-
+| `MAX_RECONNECT_FETCH_LIMIT` | Макс. кол-во сообщений для дозагрузки из истории | `50` |
-Назначение: дедупликация MAX->Telegram.
+| `LOG_LEVEL` | Уровень логирования (`DEBUG`, `INFO`, `WARNING`, `ERROR`) | `INFO` |
-
+
-Поля:
+---
-
+
-- `message_id TEXT NOT NULL`
+## 7. Границы ответственности продукта
-- `chat_id TEXT NOT NULL`
+
-- `forwarded_at DATETIME DEFAULT CURRENT_TIMESTAMP`
+**Входит в scope:**
-
+- Асинхронная двусторонняя пересылка текста и медиа через Redis-очереди.
-Ключ:
+- Подключение к MAX через **WebSocket** с обработкой разрывов связи.
-
+- Хранение и использование **маркеров последнего сообщения** для предотвращения потери данных.
-- `PRIMARY KEY (message_id, chat_id)`
+- Автоматическое создание топиков и **строгая маршрутизация только по идентификаторам**.
-
+- Соблюдение rate limits и настройка уровня логирования.
-### 7.2 Таблица `message_mapping`
+- Поддержка тредов, дедупликация, равенство участников форума.
-
+- Удалённое управление MAX (`/start`, `/help`, `/list` и др.) только для fallback-пользователя.
-Назначение: двусторонняя связка сообщений для reply и трассировки.
+- Архитектурное соблюдение слоёв, SOLID, KISS.
-
+- Контейнеризация (Docker + Docker Compose).
-Поля:
+
-
+**Не входит в scope:**
-- `telegram_chat_id TEXT NOT NULL`
+- Маршрутизация по названиям чатов/контактов.
-- `telegram_message_id TEXT NOT NULL`
+- Автоматическое переименование топиков при смене имени в MAX.
-- `max_chat_id TEXT NOT NULL`
+- Редактирование и удаление доставленных сообщений.
-- `max_message_id TEXT NOT NULL`
+- Синхронизация статусов «прочитано», индикаторов набора текста, звонков.
-- `media_group_id TEXT NULL`
+
-- `created_at DATETIME DEFAULT CURRENT_TIMESTAMP`
+---
-
+
-Ключ:
+## 8. Критерии приёмки (Бизнес и Технические)
-
+
-- `PRIMARY KEY (telegram_chat_id, telegram_message_id)`
+| № | Критерий | Тип проверки |
-
+|---|----------|--------------|
-Индексы:
+| 1 | Приложение успешно запускается командой `docker compose up -d`. | Технический |
-
+| 2 | SQLite работает в режиме WAL, Redis сохраняет очередь между рестартами. | Технический |
-- `(max_chat_id, max_message_id)` — поиск Telegram-сообщения по MAX;
+| 3 | Подключение к MAX осуществляется по **WebSocket**, автоматическое переподключение при обрыве. | Технический |
-- `(telegram_chat_id, media_group_id)` — групповые операции альбомов.
+| 4 | **Архитектура**: Отсутствуют прямые вызовы API одного слоя из другого. Код структурирован по слоям, соответствует SOLID и KISS. | Технический/Code Review |
-
+| 5 | В SQLite корректно обновляется `last_processed_message_id`. Дубликаты при переподключении WS не попадают в очередь. | Технический |
-### 7.3 Таблица `chat_routes`
+| 6 | **Сценарий даунтайма**: После 5-минутного простоя пропущенные сообщения доставляются без потерь и дублей. | Бизнес/Технический |
-
+| 7 | Переименование чата в MAX **не прерывает** пересылку (маршрутизация строго по ID). | Бизнес |
-Назначение: явные маршруты MAX chat title -> Telegram chat id.
+| 8 | Сообщение из TG пересылается в MAX **только если** маппинг найден в БД. | Бизнес |
-
+| 9 | При флуде (10+ сообщений) соблюдаются интервалы: ≥ 3.5 сек (TG) и ≥ `MAX_RATE_LIMIT_DELAY_SEC` (MAX). Ошибки `429` отсутствуют. | Технический |
-Поля:
+| 10 | Реакция 🦄 ставится в TG **строго после** успешной отправки из очереди в MAX. | Бизнес |
-
+| 11 | Любой участник форума может писать в маппированный ЛС-топик, сообщение доходит до контакта в MAX. | Бизнес |
-- `max_chat_title_norm TEXT PRIMARY KEY`
+| 12 | Команды `/start`, `/help`, `/list` и др. работают **только** в личной переписке и **только** от `FALLBACK_USER_ID`. | Бизнес |
-- `telegram_chat_id TEXT NOT NULL`
+| 13 | Уровень логирования (`LOG_LEVEL`) применяется ко всем компонентам, логи структурированы в JSON. | Технический |
-- `telegram_chat_title TEXT NULL`
+| 14 | При критической ошибке отправки fallback-пользователь получает уведомление в ЛС с деталями. | Бизнес |
-- `created_at DATETIME DEFAULT CURRENT_TIMESTAMP`
-
-Нормализация ключа:
-
-- trim + casefold/lower (без учета регистра).
-
-## 8. Алгоритмы и правила
-
-## 8.1 Нормализация названий чатов
-
-Во всех маршрутизирующих сравнениях:
-
-- удалить крайние пробелы;
-- привести к регистронезависимой форме (`casefold`/`lower`);
-- сравнивать только в нормализованном виде.
-
-## 8.2 Политика маршрутизации MAX -> Telegram
-
-Порядок выбора:
-
-1. `chat_routes` по нормализованному MAX title;
-2. локальный кэш Telegram title->id (наполняется из `getUpdates`);
-3. fallback user/chat id.
-
-## 8.3 Политика медиа
-
-- MAX->Telegram:
-  - если суммарно фото+видео больше одного, использовать album API;
-  - документы отправлять отдельными сообщениями;
-  - caption добавлять только к первому элементу/первому отправляемому сообщению.
-- Telegram->MAX:
-  - фото/видео отправлять как native attachments;
-  - прочие типы файлов прикладывать ссылками в тексте.
-
-## 8.4 Reply-семантика
-
-- Для Telegram->MAX:
-  - если Telegram message является reply, искать соответствующий `max_message_id` в mapping;
-  - если найден, отправлять `reply_to` в MAX.
-- Для MAX->Telegram:
-  - если MAX message является reply, искать `telegram_message_id` в mapping;
-  - если MAX message является reply, не копировать медиа из `link.message` (исходного сообщения);
-  - если найден, отправлять `reply_to_message_id`;
-  - если не найден, добавлять текстовую пометку с превью исходного сообщения.
-
-## 8.5 Обработка migration в Telegram
-
-Если Telegram API возвращает ошибку с `parameters.migrate_to_chat_id`:
-
-1. обновить маршрут в `chat_routes` на новый chat id;
-2. повторить отправку в новый chat id;
-3. считать повтор успешным итоговым результатом.
-
-## 8.6 Дедупликация
-
-- применяется для MAX->Telegram по ключу `(max_message_id, max_chat_id)`;
-- после успешной отправки обязательно mark-forwarded;
-- на старте/рестарте состояния берутся из БД.
-
-## 8.7 Buffering media group (Telegram)
-
-- ключ буфера: `(telegram_chat_id, media_group_id)`;
-- каждое сообщение альбома копится в списке;
-- по истечении grace-периода группа отправляется одним вызовом в MAX;
-- после отправки буфер очищается.
-
-## 9. API-контракты внутренних модулей
-
-Ниже абстрактные контракты, независимые от языка:
-
-- `Settings load_settings()`
-  - читает env;
-  - валидирует обязательные поля;
-  - возвращает immutable-конфигурацию.
-
-- `ParsedMessage parse_message(MaxMessage msg)`
-  - best-effort преобразование сырого MAX-сообщения в каноническую структуру.
-
-- `BridgeStorage`
-  - `was_forwarded(message_id, chat_id) -> bool`
-  - `mark_forwarded(message_id, chat_id)`
-  - `save_mapping(telegram_chat_id, telegram_message_id, max_chat_id, max_message_id, media_group_id?)`
-  - `get_max_message_id_for_telegram(telegram_chat_id, telegram_message_id) -> str?`
-  - `get_telegram_message_id_for_max(telegram_chat_id, max_chat_id, max_message_id) -> str?`
-  - `set_chat_route(max_chat_title_norm, telegram_chat_id, telegram_chat_title?)`
-  - `get_chat_route(max_chat_title_norm) -> str?`
-
-- `TelegramClient`
-  - `resolve_target_chat_id(max_chat_name) -> (chat_id, matched_by_title)`
-  - `send_text/send_photo/send_video/send_document/send_media_group(...)`
-  - `get_updates(offset, timeout, limit) -> updates[]`
-  - `get_file_url(file_id) -> url`
-  - `add_reaction(chat_id, message_id, emoji)`
-
-- `MaxToTelegramBridge.forward_message(max_message)`
-- `TelegramToMaxBridge.start()`
-- `handle_control_command(message, max_client, telegram) -> str?`
-
-## 10. Health-check модель
-
-Должны храниться timestamps:
-
-- telegram: `last_ok`, `last_error`;
-- max: `last_ok`, `last_error`, `last_event`;
-- `started_at`.
-
-Параметр:
-
-- `unhealthy_after_sec` (по умолчанию ~15 минут).
-
-Правила:
-
-- `telegram_healthy = last_ok exists && now-last_ok <= unhealthy_after_sec`;
-- `max_healthy = last_ok exists && now-last_ok <= unhealthy_after_sec`;
-- `overall_healthy = telegram_healthy && max_healthy`.
-
-HTTP:
-
-- `GET /livez` (и `/live`, `/`) -> 200, `{status:"live", uptime_sec}`.
-- `GET /healthz` (и `/health`) -> 200 или 503, детальный JSON по компонентам.
-
-## 11. Поведение при ошибках и устойчивость
-
-- Любая ошибка обработки отдельного сообщения не должна останавливать сервис.
-- Polling Telegram при ошибке уходит в backoff (например 10 секунд).
-- Ошибка реакции в Telegram не влияет на основную доставку.
-- Ошибка аварийного уведомления логируется, но не роняет процесс.
-- Проблемы с разрешением URL медиа обрабатываются best-effort:
-  - что удалось достать — отправляется;
-  - что не удалось — отражается в тексте/unknown notices.
-
-## 12. Логирование и диагностика
-
-Обязательные события логов:
-
-- старт/остановка компонентов;
-- маршрутизация сообщений;
-- обнаружение дубликатов;
-- ошибки API и stacktrace;
-- успешная пересылка с количеством вложений;
-- операции bind и migration chat id.
-
-Рекомендуемый формат:
-
-- timestamp + level + logger + message.
-
-## 13. Сценарии запуска и деплой
-
-## 13.1 Локальный запуск
-
-1. Подготовить `.env`.
-2. Установить зависимости.
-3. Один раз пройти auth MAX (интерактивно), сохранить сессию.
-4. Запустить основной процесс.
-
-## 13.2 Контейнерный запуск
-
-- контейнер должен включать runtime + зависимости;
-- каталог `cache` должен быть volume для сохранения сессии и SQLite;
-- должен быть healthcheck через `GET /healthz`.
-
-## 13.3 CI/CD (рекомендованно)
-
-- сборка Docker image при push в основные ветки;
-- публикация в registry с тегами для dev/release/latest;
-- кэширование слоев сборки.
-
-## 14. Требования к переносимой реализации (на любом языке)
-
-Чтобы воссоздать проект в другом языке, необходимо сохранить:
-
-1. Два независимых, но согласованных канала обработки:
-   - event-driven для MAX сообщений;
-   - polling-loop для Telegram updates.
-2. Единое постоянное хранилище с тремя сущностями:
-   - dedup;
-   - mapping;
-   - routes.
-3. Идентичные правила нормализации названий чатов и выбора маршрута.
-4. Reply-механику с fallback-текстом при отсутствии mapping.
-5. Политику media group и порядок отправки вложений.
-6. Обработку Telegram migration (`migrate_to_chat_id`) с обновлением маршрута.
-7. Health-модель с независимыми метками MAX/Telegram.
-8. Ограничение: только один consumer `getUpdates` на экземпляр бота.
-
-## 15. Acceptance criteria
-
-Система считается реализованной, если:
-
-1. Текст/фото/видео/файлы корректно ходят в обе стороны.
-2. MAX->Telegram не дублирует уже пересланные сообщения после рестарта.
-3. Reply в обе стороны сохраняется, если mapping существует.
-4. При отсутствии Telegram-совпадения сообщение уходит в fallback.
-5. `/bind_max` меняет маршрут и влияет на последующие MAX->Telegram сообщения.
-6. Telegram media group приходит в MAX как одно сообщение с множеством вложений.
-7. `/healthz` возвращает 200 при рабочем MAX+Telegram и 503 при деградации.
-8. Ошибки отдельных сообщений не приводят к остановке процесса.
-
-## 16. Известные ограничения текущей логики
-
-- Автопоиск Telegram-чата зависит от того, что чат уже встречался в `getUpdates`.
-- Для нестандартных вложений возможна частичная деградация в plain text + ссылки.
-- Дедупликация реализована только для потока MAX->Telegram.
-- Конкурентный доступ к SQLite через множество соединений допустим для небольших нагрузок, но для high-load может потребоваться иной storage backend.
-
-## 17. Рекомендации для расширения (необязательно)
-
-- добавить миграции схемы БД;
-- добавить retry policy с классификацией transient/permanent ошибок;
-- добавить метрики (Prometheus/OpenTelemetry);
-- добавить интеграционные тесты с моками API MAX/Telegram;
-- добавить персистентный offset Telegram (если нужен recovery без повторов между рестартами).
-