по реакции теперь сохраняем сообщение

При реакции на сообщение в Telegram, дублируется сообщение в Discord
Чат-бот для объединения Telegram и Discord в ROX, в отличии от основого нет ВК и сайта
2026-04-22 23:27:35 +02:00 · 2026-04-22 19:19:07 +02:00 · 2026-04-22 18:27:05 +02:00
16 changed files with 370 additions and 1223 deletions
@@ -1,2 +1 @@
 .env
-go-chat-bridge
@@ -1,39 +1,19 @@
 # Go Chat Bridge Dockerfile
 FROM golang:1.22-alpine AS builder
 WORKDIR /app
-# Сначала только зависимости — этот слой кэшируется, пока не меняются go.mod/go.sum
-COPY go.mod go.sum ./
-RUN go mod download
-# Код копируем отдельно — любое изменение .go пересобирает бинарник
-# Версию можно задать: docker build --build-arg VERSION=1.0.0
-ARG VERSION=dev
-COPY *.go ./
-RUN BUILD_DATE=$(date -u +%Y-%m-%dT%H:%M:%SZ) && \
-    go build -ldflags "-X main.Version=${VERSION} -X main.BuildDate=$BUILD_DATE" -o chat-bridge .
+COPY . .
+RUN go mod tidy && go build -o chat-bridge .

 FROM alpine:latest
-RUN apk add --no-cache ca-certificates ffmpeg python3 py3-pip \
-	&& pip3 install --break-system-packages --no-cache-dir yt-dlp \
-	&& yt-dlp --version
 WORKDIR /app
 COPY --from=builder /app/chat-bridge .

 # Переменные окружения (можно задать через docker run -e ...)
 ENV TELEGRAM_TOKEN=""
 ENV DISCORD_TOKEN=""
-ENV VK_TOKEN=""
 ENV TELEGRAM_CHAT_ID=""
 ENV DISCORD_CHANNEL_ID=""
-ENV VK_PEER_ID=""
-ENV VK_GROUP_ID=""
-ENV MAX_TOKEN=""
-ENV MAX_CHAT_ID=""
-ENV MAX_USE_WEBHOOK=""
-ENV MAX_WEBHOOK_SECRET=""
-ENV SITE_API_URL=""
-ENV SITE_API_TOKEN=""
-ENV WEBHOOK_API_KEY=""
-ENV PUBLIC_URL=""
-ENV MEDIA_PROXY_SECRET=""
+ENV DISCORD_REACTION_CHANNEL_ID=""
+ENV TELEGRAM_DUPLICATE_REACTION="✍️"

 CMD ["./chat-bridge"]
@@ -1,137 +1,69 @@
 # Go Chat Bridge

-Мультичат-бот для объединения чатов в **Telegram**, **Discord**, **VK**, **MAX** и на **вашем сайте**.
+Мультичат-бот для объединения Telegram и Discord.

 ## Возможности
-
- Пересылка сообщений между Telegram, Discord, VK, MAX и сайтом
- Отображение имени отправителя в пересылаемых сообщениях (`[TG]`, `[DS]`, `[VK]`, `[MAX]`, `[SITE]`)
- **Медиа**: фото, документы, видео, аудио, голосовые, GIF
-  - В **Discord** и **Telegram** медиа отправляются как вложения (файлы)
-  - В **VK** и на **сайт** — ссылками на прокси (без токена бота в URL)
-  - **YouTube → MAX**: если в сообщении есть ссылка на YouTube и ролик **короче 5 минут**, видео скачивается (`yt-dlp`) и отправляется в MAX как вложение (лимит MAX 250 МБ); иначе остаётся ссылка
- **Медиа-прокси**: ссылки из Telegram не содержат токен бота; файлы отдаются через ваш сервер
- **Webhook** для приёма сообщений с сайта (POST `/webhook`)
- Загрузка переменных из файла `.env` при запуске
- Версия и дата сборки в логах при старте
+- Пересылка сообщений между Telegram и Discord
+- Отображение имени отправителя в пересылаемых сообщениях
+- Поддержка медиафайлов (изображения, видео, документы)

 ## Быстрый старт

-### 1. Клонирование и зависимости
+1. Клонируйте репозиторий:
+   ```bash
+   git clone <repo_url>
+   cd turn-rox-bridge
+   ```
+2. Установите зависимости:
+   ```bash
+   go mod tidy
+   ```
+3. Создайте и настройте ботов/токены для платформ:
+   - Telegram: получите токен у @BotFather
+   - Discord: создайте приложение и получите токен
+4. Укажите переменные окружения:
+   ```bash
+   export TELEGRAM_TOKEN=...         # токен Telegram-бота
+   export DISCORD_TOKEN=...          # токен Discord-бота
+   export TELEGRAM_CHAT_ID=...       # id чата/канала Telegram
+   export DISCORD_CHANNEL_ID=...     # id канала Discord
+   export DISCORD_REACTION_CHANNEL_ID=...  # доп. канал Discord для дубля по реакции
+   export TELEGRAM_DUPLICATE_REACTION=✍️   # какая реакция триггерит дубль
+   ```
+5. Запустите приложение:
+   ```bash
+   go run .
+   ```

-```bash
-git clone <repo_url>
-cd turn-bridge
-go mod tidy
-```
+## Формат пересылаемых сообщений

-### 2. Токены и ID
+- `[TG] user: текст` — из Telegram
+- `[DS] user: текст` — из Discord

- **Telegram**: токен у [@BotFather](https://t.me/BotFather), ID чата/канала
- **Discord**: токен приложения, ID канала
- **VK**: токен группы с правами `messages`, `groups` (см. раздел ниже), `VK_PEER_ID` беседы, `VK_GROUP_ID`
- **MAX**: токен в [платформе MAX](https://dev.max.ru/docs-api) (Чат-боты → Интеграция), ID чата `MAX_CHAT_ID`
+## Пример .env

-### 3. Переменные окружения
-
-Создайте `.env` в корне проекта (при запуске бинарника переменные подхватываются автоматически):
+Создайте файл `.env` в корне проекта и заполните:

 ```env
-# Обязательные
-TELEGRAM_TOKEN=...
-DISCORD_TOKEN=...
-VK_TOKEN=...
-
-# ID чатов
+TELEGRAM_TOKEN=your_telegram_token
+DISCORD_TOKEN=your_discord_token
 TELEGRAM_CHAT_ID=-1001234567890
 DISCORD_CHANNEL_ID=123456789012345678
-VK_PEER_ID=2000000002
-VK_GROUP_ID=15469861
-
-# MAX (опционально)
-MAX_TOKEN=...
-MAX_CHAT_ID=123456789
-# MAX_USE_WEBHOOK=true  # для production: webhook вместо long polling
-# MAX_WEBHOOK_SECRET=...  # секрет для проверки заголовка X-Max-Bot-Api-Secret
-
-# Сайт: отправка сообщений на сайт и приём с сайта
-SITE_API_URL=https://your-site.com/telebot/chat_api.php
-SITE_API_TOKEN=...
-WEBHOOK_API_KEY=...
-
-# Медиа-прокси (чтобы в ссылках для VK и сайта не светить токен Telegram)
-PUBLIC_URL=https://your-bridge-host:8080
-MEDIA_PROXY_SECRET=длинная-секретная-строка
+DISCORD_REACTION_CHANNEL_ID=123456789012345679
+TELEGRAM_DUPLICATE_REACTION=✍️
 ```

- **PUBLIC_URL** — базовый URL, по которому доступен этот сервис (порт 8080). По нему отдаются ссылки вида `PUBLIC_URL/media/...`.
- **MEDIA_PROXY_SECRET** — секрет для подписи ссылок на медиа. Без него прокси отключён, в VK и на сайт пойдут прямые ссылки Telegram (с токеном бота).
+docker-compose автоматически подхватит эти переменные.

-### 4. Запуск
+## Дублирование по реакции Telegram

-**Локально:**
-
-```bash
-./go-chat-bridge
-# или
-go run .
-```
-
-**Docker:**
-
-```bash
-docker-compose up -d --build
-```
-
-При сборке образа можно задать версию:  
-`docker build --build-arg VERSION=1.0.0 -t chat-bridge .`
-
-## Эндпоинты (порт 8080)
-
-| Путь       | Описание |
-|-----------|----------|
-| `POST /webhook` | Приём сообщений с сайта. Параметр `key` (или поле `key` в JSON) = `WEBHOOK_API_KEY`; в теле — `text`, `sender`. |
-| `POST /max/webhook` | Приём событий от MAX (режим webhook). Проверка заголовка `X-Max-Bot-Api-Secret` при заданном `MAX_WEBHOOK_SECRET`. |
-| `GET /media/<токен>/<имя_файла>.<расширение>` | Прокси медиа из Telegram. Токен подписан, расширение в URL для корректного отображения и сохранения. |
-
-## Формат сообщений в чатах
-
- `[TG] Имя: текст` — из Telegram  
- `[DS] Имя: текст` — из Discord  
- `[VK] Имя: текст` — из VK  
- `[MAX] Имя: текст` — из MAX  
- `[SITE] Имя: текст` — с сайта  
-
-При наличии медиа к сообщению добавляются ссылки (в VK и на сайте — на прокси с расширением в конце, например `.../media/xxx/file_332.jpg`).
-
-## Получение токена VK
-
-1. В настройках группы VK включите Long Poll API и разрешите сообщения.
-2. Создайте Standalone-приложение VK, получите токен по ссылке:
-   ```
-   https://oauth.vk.com/authorize?client_id=ВАШ_CLIENT_ID&display=page&redirect_uri=https://oauth.vk.com/blank.html&scope=messages,groups&response_type=token&v=5.131
-   ```
-   Скопируйте `access_token` из адресной строки после редиректа.
-
-## Настройка MAX
-
-1. Создайте бота на [платформе MAX](https://dev.max.ru/docs-api) и получите токен.
-2. Добавьте бота в групповой чат (бот должен быть администратором для получения событий из групп).
-3. Задайте `MAX_TOKEN` и `MAX_CHAT_ID` (ID чата, куда пересылать и откуда принимать сообщения).
-4. **Long polling** (по умолчанию) — для разработки и тестирования; запускается автоматически при наличии `MAX_TOKEN`.
-5. **Webhook** (production) — задайте `MAX_USE_WEBHOOK=true`, `PUBLIC_URL=https://...` (HTTPS на порту 443) и опционально `MAX_WEBHOOK_SECRET`. При старте бот зарегистрирует подписку `POST /subscriptions` на `PUBLIC_URL/max/webhook`.
-
-Для пересылки коротких YouTube-роликов в MAX на хосте (или в Docker-образе) нужны `yt-dlp` и `ffmpeg`.
-
-## Логи
-
-При старте выводятся:
-
- Загрузка `.env` (или сообщение, что файл не найден)
- Версия и дата сборки (при сборке через Docker — дата сборки образа)
- Состояние медиа-прокси (включён / выключен)
- Служебные сообщения `[Telegram]`, `[Media]`, `[Bridge]` при пересылке и отдаче медиа
+Если у Telegram-сообщения добавлена реакция, указанная в `TELEGRAM_DUPLICATE_REACTION` (по умолчанию `✍️`), то это сообщение дополнительно отправляется в `DISCORD_REACTION_CHANNEL_ID` помимо основного `DISCORD_CHANNEL_ID`.
+## TODO
+- Поддержка вложений и файлов
+- Админ-команды
+- Логирование событий

 ## Лицензия
-
 MIT
+
+
@@ -1,68 +1,25 @@
 package main

 import (
-	"crypto/hmac"
-	"crypto/sha256"
-	"encoding/base64"
-	"fmt"
 	"io"
 	"mime"
 	"net/http"
 	"net/url"
 	"os"
 	"path"
-	"strconv"
 	"strings"

-	"github.com/SevereCloud/vksdk/v2/api"
 	"github.com/bwmarrin/discordgo"
 	tgbotapi "github.com/go-telegram-bot-api/telegram-bot-api/v5"
 )

-// Отправка сообщения на сайт
-func (b *Bridge) SendToSite(text string) error {
-	apiURL := os.Getenv("SITE_API_URL")
-	token := os.Getenv("SITE_API_TOKEN")
-	if apiURL == "" || token == "" {
-		return fmt.Errorf("SITE_API_URL или SITE_API_TOKEN не заданы")
-	}
-	fullURL := fmt.Sprintf("%s?token=%s&text=%s", apiURL, token, url.QueryEscape(text))
-
-	req, err := http.NewRequest("GET", fullURL, nil)
-	if err != nil {
-		return err
-	}
-	req.Header.Set("Accept", "application/json")
-
-	client := &http.Client{}
-	resp, err := client.Do(req)
-	if err != nil {
-		return err
-	}
-	defer resp.Body.Close()
-
-	_, err = io.ReadAll(resp.Body)
-	return err
-}
-
-// Получить имя пользователя VK по id
-func (b *Bridge) GetVKUserName(userID int) (string, error) {
-	resp, err := b.VK.UsersGet(api.Params{"user_ids": userID})
-	if err != nil || len(resp) == 0 {
-		return strconv.Itoa(userID), err
-	}
-	return resp[0].FirstName + " " + resp[0].LastName, nil
-}
-
 // Структура для хранения клиентов
 type Bridge struct {
 	Telegram *tgbotapi.BotAPI
 	Discord  *discordgo.Session
-	VK       *api.VK
-	MAXToken string
 }

-func NewBridge(telegramToken, discordToken, vkToken, maxToken string) (*Bridge, error) {
+func NewBridge(telegramToken, discordToken string) (*Bridge, error) {
 	// Telegram
 	tgBot, err := tgbotapi.NewBotAPI(telegramToken)
 	if err != nil {
@@ -75,69 +32,12 @@ func NewBridge(telegramToken, discordToken, vkToken, maxToken string) (*Bridge,
 		return nil, err
 	}

-	// VK
-	vk := api.NewVK(vkToken)
-
 	return &Bridge{
 		Telegram: tgBot,
 		Discord:  dg,
-		VK:       vk,
-		MAXToken: maxToken,
 	}, nil
 }

-// signMediaToken создаёт подписанный токен для filePath (HMAC-SHA256), чтобы не светить токен бота в ссылках.
-func signMediaToken(filePath, secret string) string {
-	mac := hmac.New(sha256.New, []byte(secret))
-	mac.Write([]byte(filePath))
-	sig := mac.Sum(nil)
-	// payload.base64(sig) — в URL без padding
-	enc := base64.URLEncoding.WithPadding(base64.NoPadding)
-	return enc.EncodeToString([]byte(filePath)) + "." + enc.EncodeToString(sig)
-}
-
-// verifyMediaToken проверяет подпись и возвращает filePath. secret должен совпадать с тем, что при подписи.
-func verifyMediaToken(token, secret string) (filePath string, ok bool) {
-	enc := base64.URLEncoding.WithPadding(base64.NoPadding)
-	idx := strings.LastIndex(token, ".")
-	if idx == -1 {
-		return "", false
-	}
-	payloadB, err1 := enc.DecodeString(token[:idx])
-	sigB, err2 := enc.DecodeString(token[idx+1:])
-	if err1 != nil || err2 != nil || len(sigB) != sha256.Size {
-		return "", false
-	}
-	filePath = string(payloadB)
-	mac := hmac.New(sha256.New, []byte(secret))
-	mac.Write([]byte(filePath))
-	expected := mac.Sum(nil)
-	if !hmac.Equal(sigB, expected) {
-		return "", false
-	}
-	return filePath, true
-}
-
-// GetTelegramFileProxyURL возвращает публичный URL прокси для файла Telegram (без токена в ссылке).
-// В конец URL добавлено имя файла с расширением, чтобы ссылка в чате показывала .jpg и т.д.
-func (b *Bridge) GetTelegramFileProxyURL(filePath string) string {
-	publicURL := strings.TrimSuffix(os.Getenv("PUBLIC_URL"), "/")
-	secret := os.Getenv("MEDIA_PROXY_SECRET")
-	if publicURL == "" || secret == "" {
-		return ""
-	}
-	fileName := path.Base(filePath)
-	if fileName == "" || fileName == "." {
-		fileName = "file"
-	}
-	return publicURL + "/media/" + signMediaToken(filePath, secret) + "/" + url.PathEscape(fileName)
-}
-
-// GetTelegramFileDirectURL возвращает прямую ссылку на файл Telegram (только для внутреннего использования на сервере).
-func (b *Bridge) GetTelegramFileDirectURL(filePath string) string {
-	return fmt.Sprintf("https://api.telegram.org/file/bot%s/%s", b.Telegram.Token, filePath)
-}
-
 // Отправка сообщения в Telegram
 func (b *Bridge) SendToTelegram(chatID int64, text string) error {
 	msg := tgbotapi.NewMessage(chatID, text)
@@ -151,16 +51,6 @@ func (b *Bridge) SendToDiscord(channelID, text string) error {
 	return err
 }

-// Отправка сообщения в VK
-func (b *Bridge) SendToVK(peerID int, text string) error {
-	_, err := b.VK.MessagesSend(api.Params{
-		"peer_id":   peerID,
-		"message":   text,
-		"random_id": 0,
-	})
-	return err
-}
-
 // Загруженный файл на диск для пересылки как вложение
 type DownloadedFile struct {
 	FileName string
@@ -1,25 +1,13 @@
 version: '3.8'
 services:
-  chat-bridge:
+  chat-rox-bridge:
    build: .
-    container_name: chat-bridge
+    container_name: chat-rox-bridge
    environment:
      TELEGRAM_TOKEN: "${TELEGRAM_TOKEN}"
      DISCORD_TOKEN: "${DISCORD_TOKEN}"
-      VK_TOKEN: "${VK_TOKEN}"
      TELEGRAM_CHAT_ID: "${TELEGRAM_CHAT_ID}"
      DISCORD_CHANNEL_ID: "${DISCORD_CHANNEL_ID}"
-      VK_PEER_ID: "${VK_PEER_ID}"
-      VK_GROUP_ID: "${VK_GROUP_ID}"
-      MAX_TOKEN: "${MAX_TOKEN}"
-      MAX_CHAT_ID: "${MAX_CHAT_ID}"
-      MAX_USE_WEBHOOK: "${MAX_USE_WEBHOOK:-false}"
-      MAX_WEBHOOK_SECRET: "${MAX_WEBHOOK_SECRET}"
-      SITE_API_URL: "${SITE_API_URL}"
-      SITE_API_TOKEN: "${SITE_API_TOKEN}"
-      WEBHOOK_API_KEY: "${WEBHOOK_API_KEY}"
-      PUBLIC_URL: "${PUBLIC_URL}"
-      MEDIA_PROXY_SECRET: "${MEDIA_PROXY_SECRET}"
+      DISCORD_REACTION_CHANNEL_ID: "${DISCORD_REACTION_CHANNEL_ID}"
+      TELEGRAM_DUPLICATE_REACTION: "${TELEGRAM_DUPLICATE_REACTION}"
    restart: unless-stopped
-    ports:
-      - "8080:8080"
@@ -3,18 +3,12 @@ module go-chat-bridge
 go 1.22

 require (
-	github.com/SevereCloud/vksdk/v2 v2.17.0
 	github.com/bwmarrin/discordgo v0.29.0
 	github.com/go-telegram-bot-api/telegram-bot-api/v5 v5.5.1
 )

 require (
 	github.com/gorilla/websocket v1.5.3 // indirect
-	github.com/joho/godotenv v1.5.1 // indirect
-	github.com/klauspost/compress v1.17.9 // indirect
-	github.com/vmihailenco/msgpack/v5 v5.4.1 // indirect
-	github.com/vmihailenco/tagparser/v2 v2.0.0 // indirect
 	golang.org/x/crypto v0.0.0-20210421170649-83a5a9bb288b // indirect
 	golang.org/x/sys v0.0.0-20201119102817-f84b799fce68 // indirect
-	golang.org/x/text v0.16.0 // indirect
 )
@@ -1,26 +1,10 @@
-github.com/SevereCloud/vksdk/v2 v2.17.0 h1:Wll63JSuBTdE0L7+V/PMn9PyhLrWSWIjX76XpWbXTFw=
-github.com/SevereCloud/vksdk/v2 v2.17.0/go.mod h1:y3q3XAdqnQ2Wf0B+Wi7qNdqJc5ZZsz4ve+DoSQsrChk=
 github.com/bwmarrin/discordgo v0.29.0 h1:FmWeXFaKUwrcL3Cx65c20bTRW+vOb6k8AnaP+EgjDno=
 github.com/bwmarrin/discordgo v0.29.0/go.mod h1:NJZpH+1AfhIcyQsPeuBKsUtYrRnjkyu0kIVMCHkZtRY=
-github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
-github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/go-telegram-bot-api/telegram-bot-api/v5 v5.5.1 h1:wG8n/XJQ07TmjbITcGiUaOtXxdrINDz1b0J1w0SzqDc=
 github.com/go-telegram-bot-api/telegram-bot-api/v5 v5.5.1/go.mod h1:A2S0CWkNylc2phvKXWBBdD3K0iGnDBGbzRpISP2zBl8=
 github.com/gorilla/websocket v1.4.2/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE=
 github.com/gorilla/websocket v1.5.3 h1:saDtZ6Pbx/0u+bgYQ3q96pZgCzfhKXGPqt7kZ72aNNg=
 github.com/gorilla/websocket v1.5.3/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE=
-github.com/joho/godotenv v1.5.1 h1:7eLL/+HRGLY0ldzfGMeQkb7vMd0as4CfYvUVzLqw0N0=
-github.com/joho/godotenv v1.5.1/go.mod h1:f4LDr5Voq0i2e/R5DDNOoa2zzDfwtkZa6DnEwAbqwq4=
-github.com/klauspost/compress v1.17.9 h1:6KIumPrER1LHsvBVuDa0r5xaG0Es51mhhB9BQB2qeMA=
-github.com/klauspost/compress v1.17.9/go.mod h1:Di0epgTjJY877eYKx5yC51cX2A2Vl2ibi7bDH9ttBbw=
-github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
-github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
-github.com/stretchr/testify v1.9.0 h1:HtqpIVDClZ4nwg75+f6Lvsy/wHu+3BoSGCbBAcpTsTg=
-github.com/stretchr/testify v1.9.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
-github.com/vmihailenco/msgpack/v5 v5.4.1 h1:cQriyiUvjTwOHg8QZaPihLWeRAAVoCpE00IUPn0Bjt8=
-github.com/vmihailenco/msgpack/v5 v5.4.1/go.mod h1:GaZTsDaehaPpQVyxrf5mtQlH+pc21PIudVV/E3rRQok=
-github.com/vmihailenco/tagparser/v2 v2.0.0 h1:y09buUbR+b5aycVFQs/g70pqKVZNBmxwAhO7/IwNM9g=
-github.com/vmihailenco/tagparser/v2 v2.0.0/go.mod h1:Wri+At7QHww0WTrCBeu4J6bNtoV6mEfg5OIWRZA9qds=
 golang.org/x/crypto v0.0.0-20210421170649-83a5a9bb288b h1:7mWr3k41Qtv8XlltBkDkl8LoP3mpSgBW8BUoxtEdbXg=
 golang.org/x/crypto v0.0.0-20210421170649-83a5a9bb288b/go.mod h1:T9bdIzuCu7OtxOm1hfPfRQxPLYneinmdGuTeoZ9dtd4=
 golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
@@ -28,8 +12,4 @@ golang.org/x/sys v0.0.0-20201119102817-f84b799fce68 h1:nxC68pudNYkKU6jWhgrqdreuF
 golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
 golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
-golang.org/x/text v0.16.0 h1:a94ExnEXNtEwYLGJSIUxnWoxoRz/ZcCsV63ROupILh4=
-golang.org/x/text v0.16.0/go.mod h1:GhwF1Be+LQoKShO3cGOHzqOgRrGaYc9AvblQOmPVHnI=
 golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
-gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
-gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
@@ -1,47 +1,30 @@
 package main

 import (
-	"encoding/json"
-	"io"
 	"log"
-	"net/http"
 	"os"
-	"path"
-	"path/filepath"
 	"strconv"
 	"strings"
-
-	"github.com/joho/godotenv"
+	"sync"
 )

-// Заполняются при сборке: go build -ldflags "-X main.Version=... -X main.BuildDate=..."
-var (
-	Version   = "dev"
-	BuildDate = "unknown"
-)
+type telegramMessageCacheItem struct {
+	Text   string
+	Sender string
+	Media  []string
+}

 func main() {
-	// Загружаем .env из текущей директории или рядом с бинарником
-	if err := godotenv.Load(); err != nil {
-		execPath, _ := os.Executable()
-		envPath := filepath.Join(filepath.Dir(execPath), ".env")
-		if err2 := godotenv.Load(envPath); err2 != nil {
-			log.Println("Файл .env не найден, используются переменные окружения shell")
-		}
-	}
 	log.Println("Go Chat Bridge запущен.")
-	log.Printf("Версия: %s, сборка: %s", Version, BuildDate)

 	telegramToken := os.Getenv("TELEGRAM_TOKEN")
 	discordToken := os.Getenv("DISCORD_TOKEN")
-	vkToken := os.Getenv("VK_TOKEN")
-	maxToken := os.Getenv("MAX_TOKEN")

-	if telegramToken == "" || discordToken == "" || vkToken == "" {
-		log.Fatal("Необходимо задать переменные окружения TELEGRAM_TOKEN, DISCORD_TOKEN, VK_TOKEN")
+	if telegramToken == "" || discordToken == "" {
+		log.Fatal("Необходимо задать переменные окружения TELEGRAM_TOKEN, DISCORD_TOKEN")
 	}

-	bridge, err := NewBridge(telegramToken, discordToken, vkToken, maxToken)
+	bridge, err := NewBridge(telegramToken, discordToken)
 	if err != nil {
 		log.Fatalf("Ошибка инициализации Bridge: %v", err)
 	}
@@ -49,12 +32,38 @@ func main() {
 	log.Println("Bridge успешно инициализирован:", bridge)

 	// Получаем ID чатов/каналов из переменных окружения
-	telegramChatID := os.Getenv("TELEGRAM_CHAT_ID")     // int64
-	discordChannelID := os.Getenv("DISCORD_CHANNEL_ID") // string
-	vkPeerID := os.Getenv("VK_PEER_ID")                 // int
-	maxChatID := os.Getenv("MAX_CHAT_ID")               // int64
+	telegramChatID := strings.TrimSpace(os.Getenv("TELEGRAM_CHAT_ID"))                      // int64
+	discordChannelID := strings.TrimSpace(os.Getenv("DISCORD_CHANNEL_ID"))                  // string
+	discordReactionChannelID := strings.TrimSpace(os.Getenv("DISCORD_REACTION_CHANNEL_ID")) // string
+	telegramDuplicateReactionEmoji := strings.TrimSpace(os.Getenv("TELEGRAM_DUPLICATE_REACTION"))
+	if telegramDuplicateReactionEmoji == "" {
+		telegramDuplicateReactionEmoji = "✍️"
+	}
+	normalizedDuplicateReaction := normalizeEmoji(telegramDuplicateReactionEmoji)

-	forward := func(text string, from string, sender string, media []string) {
+	messageCache := make(map[string]telegramMessageCacheItem)
+	var cacheMu sync.RWMutex
+
+	cacheKey := func(chatID int64, messageID int) string {
+		return strconv.FormatInt(chatID, 10) + ":" + strconv.Itoa(messageID)
+	}
+
+	sendTelegramMessageToDiscord := func(channelID, sender, text, msg string, media []string) error {
+		if channelID == "" {
+			return nil
+		}
+		if len(media) > 0 {
+			files, derr := bridge.DownloadFiles(media)
+			if derr == nil && len(files) > 0 {
+				err := bridge.SendFilesToDiscord(channelID, files, "[TG] "+sender+": "+text)
+				bridge.CleanupFiles(files)
+				return err
+			}
+		}
+		return bridge.SendToDiscord(channelID, "[TG] "+sender+": "+msg)
+	}
+
+	forward := func(text string, from string, sender string, media []string, messageID int, sourceChatID int64) {
 		// Собираем итоговый текст с медиа URL, если есть
 		msg := text
 		if len(media) > 0 {
@@ -68,31 +77,16 @@ func main() {
 		switch from {
 		case "telegram":
 			// Для Discord отправляем файлы, если есть, иначе текст
-			if discordChannelID != "" {
-				if len(media) > 0 {
-					files, derr := bridge.DownloadFiles(media)
-					if derr == nil && len(files) > 0 {
-						_ = bridge.SendFilesToDiscord(discordChannelID, files, "[TG] "+sender+": "+text)
-						bridge.CleanupFiles(files)
-					} else {
-						_ = bridge.SendToDiscord(discordChannelID, "[TG] "+sender+": "+msg)
-					}
-				} else {
-					_ = bridge.SendToDiscord(discordChannelID, "[TG] "+sender+": "+msg)
-				}
+			if err := sendTelegramMessageToDiscord(discordChannelID, sender, text, msg, media); err != nil {
+				log.Printf("[Bridge] failed to send telegram message to main Discord channel: %v", err)
 			}
-			// Для VK и сайта оставляем ссылки
-			if vkPeerID != "" {
-				if id, err := strconv.Atoi(vkPeerID); err == nil {
-					_ = bridge.SendToVK(id, "[TG] "+sender+": "+msg)
-				}
+			cacheMu.Lock()
+			messageCache[cacheKey(sourceChatID, messageID)] = telegramMessageCacheItem{
+				Text:   text,
+				Sender: sender,
+				Media:  append([]string(nil), media...),
 			}
-			if maxChatID != "" {
-				if id, err := strconv.ParseInt(maxChatID, 10, 64); err == nil {
-					_ = bridge.SendToMAXSmart(id, "[TG] "+sender+": "+msg)
-				}
-			}
-			_ = bridge.SendToSite("[TG] " + sender + ": " + msg)
+			cacheMu.Unlock()
 		case "discord":
 			// Для Telegram отправляем файлы, если есть, иначе текст
 			if telegramChatID != "" {
@@ -110,235 +104,69 @@ func main() {
 					}
 				}
 			}
-			// Для VK и сайта оставляем ссылки
-			if vkPeerID != "" {
-				if id, err := strconv.Atoi(vkPeerID); err == nil {
-					_ = bridge.SendToVK(id, "[DS] "+sender+": "+msg)
-				}
-			}
-			if maxChatID != "" {
-				if id, err := strconv.ParseInt(maxChatID, 10, 64); err == nil {
-					_ = bridge.SendToMAXSmart(id, "[DS] "+sender+": "+msg)
-				}
-			}
-			_ = bridge.SendToSite("[DS] " + sender + ": " + msg)
-		case "vk":
-			// Если когда-либо будут передаваться ссылки на медиа из VK, для TG/Discord можем тоже отправлять файлы
-			if telegramChatID != "" {
-				if id, err := strconv.ParseInt(telegramChatID, 10, 64); err == nil {
-					if len(media) > 0 {
-						files, derr := bridge.DownloadFiles(media)
-						if derr == nil && len(files) > 0 {
-							_ = bridge.SendFilesToTelegram(id, files, "[VK] "+sender+": "+text)
-							bridge.CleanupFiles(files)
-						} else {
-							_ = bridge.SendToTelegram(id, "[VK] "+sender+": "+msg)
-						}
-					} else {
-						_ = bridge.SendToTelegram(id, "[VK] "+sender+": "+msg)
-					}
-				}
-			}
-			if discordChannelID != "" {
-				if len(media) > 0 {
-					files, derr := bridge.DownloadFiles(media)
-					if derr == nil && len(files) > 0 {
-						_ = bridge.SendFilesToDiscord(discordChannelID, files, "[VK] "+sender+": "+text)
-						bridge.CleanupFiles(files)
-					} else {
-						_ = bridge.SendToDiscord(discordChannelID, "[VK] "+sender+": "+msg)
-					}
-				} else {
-					_ = bridge.SendToDiscord(discordChannelID, "[VK] "+sender+": "+msg)
-				}
-			}
-			// Для сайта оставляем ссылки
-			if maxChatID != "" {
-				if id, err := strconv.ParseInt(maxChatID, 10, 64); err == nil {
-					_ = bridge.SendToMAXSmart(id, "[VK] "+sender+": "+msg)
-				}
-			}
-			_ = bridge.SendToSite("[VK] " + sender + ": " + msg)
-		case "site":
-			// Из сайта пока не принимаем ссылки на файлы, отправляем как текст
-			if telegramChatID != "" {
-				if id, err := strconv.ParseInt(telegramChatID, 10, 64); err == nil {
-					_ = bridge.SendToTelegram(id, "[SITE] "+sender+": "+msg)
-				}
-			}
-			if discordChannelID != "" {
-				_ = bridge.SendToDiscord(discordChannelID, "[SITE] "+sender+": "+msg)
-			}
-			if vkPeerID != "" {
-				if id, err := strconv.Atoi(vkPeerID); err == nil {
-					_ = bridge.SendToVK(id, "[SITE] "+sender+": "+msg)
-				}
-			}
-			if maxChatID != "" {
-				if id, err := strconv.ParseInt(maxChatID, 10, 64); err == nil {
-					_ = bridge.SendToMAXSmart(id, "[SITE] "+sender+": "+msg)
-				}
-			}
-		case "max":
-			if telegramChatID != "" {
-				if id, err := strconv.ParseInt(telegramChatID, 10, 64); err == nil {
-					if len(media) > 0 {
-						files, derr := bridge.DownloadFiles(media)
-						if derr == nil && len(files) > 0 {
-							_ = bridge.SendFilesToTelegram(id, files, "[MAX] "+sender+": "+text)
-							bridge.CleanupFiles(files)
-						} else {
-							_ = bridge.SendToTelegram(id, "[MAX] "+sender+": "+msg)
-						}
-					} else {
-						_ = bridge.SendToTelegram(id, "[MAX] "+sender+": "+msg)
-					}
-				}
-			}
-			if discordChannelID != "" {
-				if len(media) > 0 {
-					files, derr := bridge.DownloadFiles(media)
-					if derr == nil && len(files) > 0 {
-						_ = bridge.SendFilesToDiscord(discordChannelID, files, "[MAX] "+sender+": "+text)
-						bridge.CleanupFiles(files)
-					} else {
-						_ = bridge.SendToDiscord(discordChannelID, "[MAX] "+sender+": "+msg)
-					}
-				} else {
-					_ = bridge.SendToDiscord(discordChannelID, "[MAX] "+sender+": "+msg)
-				}
-			}
-			if vkPeerID != "" {
-				if id, err := strconv.Atoi(vkPeerID); err == nil {
-					_ = bridge.SendToVK(id, "[MAX] "+sender+": "+msg)
-				}
-			}
-			_ = bridge.SendToSite("[MAX] " + sender + ": " + msg)
 		}
 	}

-	bridge.StartTelegramListener(func(text string, sender string, media []string) { forward(text, "telegram", sender, media) })
-	bridge.StartDiscordListener(discordChannelID, func(text string, sender string, media []string) { forward(text, "discord", sender, media) })
-	bridge.StartVKListener(func(text string, sender string, media []string) { forward(text, "vk", sender, media) })
-	bridge.StartMAXListener(func(text string, sender string, media []string) { forward(text, "max", sender, media) })
-	bridge.RegisterMAXWebhookHandler(func(text string, sender string, media []string) { forward(text, "max", sender, media) })
-	bridge.SetupMAXWebhook()
-
-	// Прокси медиа Telegram: по подписанному токену отдаём файл без раскрытия токена бота в ссылках
-	http.HandleFunc("/media/", func(w http.ResponseWriter, r *http.Request) {
-		if r.Method != http.MethodGet && r.Method != http.MethodHead {
-			log.Printf("[Media] %s %s — Method not allowed", r.Method, r.URL.Path)
-			http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
-			return
-		}
-		// Путь: /media/<токен>/<имя_файла.jpg> — имя в конце только для вида, токен до последнего /
-		pathSuffix := strings.TrimPrefix(r.URL.Path, "/media/")
-		if pathSuffix == "" {
-			log.Printf("[Media] запрос без токена")
-			http.Error(w, "Not found", http.StatusNotFound)
-			return
-		}
-		token := pathSuffix
-		if idx := strings.LastIndex(pathSuffix, "/"); idx != -1 {
-			token = pathSuffix[:idx]
-		}
-		secret := os.Getenv("MEDIA_PROXY_SECRET")
-		if secret == "" {
-			log.Printf("[Media] MEDIA_PROXY_SECRET не задан, прокси отключён")
-			http.Error(w, "Proxy not configured", http.StatusInternalServerError)
-			return
-		}
-		filePath, ok := verifyMediaToken(token, secret)
-		if !ok {
-			pathLog := r.URL.Path
-			if len(pathLog) > 50 {
-				pathLog = pathLog[:50] + "..."
+	bridge.StartTelegramListener(
+		func(text string, sender string, media []string, messageID int, chatID int64) {
+			forward(text, "telegram", sender, media, messageID, chatID)
+		},
+		func(chatID int64, messageID int, reaction string) {
+			if discordChannelID != "" {
+				_ = bridge.SendToDiscord(discordChannelID, "реакция поставлена")
 			}
-			log.Printf("[Media] неверный или просроченный токен (path=%s)", pathLog)
-			http.Error(w, "Invalid or expired link", http.StatusForbidden)
-			return
-		}
-		log.Printf("[Media] отдача файла: %s", filePath)
-		directURL := bridge.GetTelegramFileDirectURL(filePath)
-		resp, err := http.Get(directURL)
-		if err != nil {
-			log.Printf("[Media] ошибка загрузки из Telegram для %s: %v", filePath, err)
-			http.Error(w, "Failed to fetch file", http.StatusBadGateway)
-			return
-		}
-		defer resp.Body.Close()
-		if resp.StatusCode != http.StatusOK {
-			log.Printf("[Media] Telegram вернул %d для %s", resp.StatusCode, filePath)
-			http.Error(w, "Upstream error", resp.StatusCode)
-			return
-		}
-		if ct := resp.Header.Get("Content-Type"); ct != "" {
-			w.Header().Set("Content-Type", ct)
-		}
-		// Имя файла с расширением — иначе при открытии/сохранении расширение теряется
-		fileName := path.Base(filePath)
-		if fileName != "" && fileName != "." {
-			w.Header().Set("Content-Disposition", "inline; filename=\""+fileName+"\"")
-		}
-		w.Header().Set("Cache-Control", "private, max-age=86400")
-		io.Copy(w, resp.Body)
-		log.Printf("[Media] отдано: %s", filePath)
-	})

-	// webhook endpoint
-	http.HandleFunc("/webhook", func(w http.ResponseWriter, r *http.Request) {
-		if r.Method != http.MethodPost {
-			http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
-			return
-		}
-		apiKey := os.Getenv("WEBHOOK_API_KEY")
-		if apiKey == "" {
-			http.Error(w, "Webhook API key not set", http.StatusInternalServerError)
-			return
-		}
-		key := r.URL.Query().Get("key")
-		if key == "" {
-			// также можно принимать ключ в теле запроса
-			var req struct {
-				Key    string `json:"key"`
-				Text   string `json:"text"`
-				Sender string `json:"sender"`
-			}
-			if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
-				http.Error(w, "Bad request", http.StatusBadRequest)
+			if discordReactionChannelID == "" {
+				log.Printf("[Bridge] reaction duplicate skipped: DISCORD_REACTION_CHANNEL_ID is empty")
 				return
 			}
-			if req.Key != apiKey {
-				http.Error(w, "Forbidden", http.StatusForbidden)
+			normalizedReaction := normalizeEmoji(reaction)
+			if normalizedReaction != normalizedDuplicateReaction {
+				log.Printf("[Bridge] reaction %q does not match configured %q", reaction, telegramDuplicateReactionEmoji)
 				return
 			}
-			forward(req.Text, "site", req.Sender, nil)
-			w.WriteHeader(http.StatusOK)
-			w.Write([]byte("ok"))
-			return
-		}
-		if key != apiKey {
-			http.Error(w, "Forbidden", http.StatusForbidden)
-			return
-		}
-		var req struct {
-			Text   string `json:"text"`
-			Sender string `json:"sender"`
-		}
-		if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
-			http.Error(w, "Bad request", http.StatusBadRequest)
-			return
-		}
-		forward(req.Text, "site", req.Sender, nil)
-		w.WriteHeader(http.StatusOK)
-		w.Write([]byte("ok"))
+
+			cacheMu.RLock()
+			item, exists := messageCache[cacheKey(chatID, messageID)]
+			cacheMu.RUnlock()
+			if !exists {
+				log.Printf("[Telegram] reaction %q for message %d in chat %d ignored: original message not in cache", reaction, messageID, chatID)
+				return
+			}
+
+			msg := item.Text
+			if len(item.Media) > 0 {
+				if msg != "" {
+					msg += "\n"
+				}
+				msg += strings.Join(item.Media, "\n")
+			}
+			if err := sendTelegramMessageToDiscord(discordReactionChannelID, item.Sender, item.Text, msg, item.Media); err != nil {
+				log.Printf("[Bridge] failed to send duplicated message to reaction Discord channel: %v", err)
+				return
+			}
+			log.Printf("[Bridge] duplicated message %d from chat %d to reaction channel by reaction %q", messageID, chatID, reaction)
+		},
+	)
+	bridge.StartDiscordListener(discordChannelID, func(text string, sender string, media []string) {
+		forward(text, "discord", sender, media, 0, 0)
 	})

-	if os.Getenv("PUBLIC_URL") != "" && os.Getenv("MEDIA_PROXY_SECRET") != "" {
-		log.Println("Медиа-прокси включён: ссылки из Telegram будут без токена в URL")
-	} else {
-		log.Println("Медиа-прокси выключен (задайте PUBLIC_URL и MEDIA_PROXY_SECRET для включения)")
-	}
-	log.Println("Webhook listening on :8080 (/webhook, /max/webhook, /media/)")
-	log.Fatal(http.ListenAndServe(":8080", nil))
+	log.Println("Chat Bridge запущен и работает")
+	select {} // Бесконечный цикл для поддержания работы программы
+}
+
+func normalizeEmoji(value string) string {
+	trimmed := strings.TrimSpace(value)
+	filtered := strings.Map(func(r rune) rune {
+		// Variation selectors and skin tone modifiers are optional in user input/reaction payloads.
+		if r == '\uFE0E' || r == '\uFE0F' {
+			return -1
+		}
+		if r >= '\U0001F3FB' && r <= '\U0001F3FF' {
+			return -1
+		}
+		return r
+	}, trimmed)
+	return filtered
 }
@@ -1,296 +0,0 @@
-package main
-
-import (
-	"bytes"
-	"encoding/json"
-	"fmt"
-	"io"
-	"log"
-	"mime/multipart"
-	"net/http"
-	"net/url"
-	"os"
-	"path/filepath"
-	"strconv"
-	"strings"
-	"time"
-)
-
-const maxAPIBase = "https://platform-api.max.ru"
-
-type maxUpdatesResponse struct {
-	Updates []maxUpdate `json:"updates"`
-	Marker  *int64      `json:"marker"`
-}
-
-type maxUpdate struct {
-	UpdateType string     `json:"update_type"`
-	Timestamp  int64      `json:"timestamp"`
-	Message    *maxMessage `json:"message"`
-}
-
-type maxMessage struct {
-	Sender    *maxUser      `json:"sender"`
-	Recipient *maxRecipient `json:"recipient"`
-	Body      *maxMessageBody `json:"body"`
-}
-
-type maxUser struct {
-	UserID    int64  `json:"user_id"`
-	FirstName string `json:"first_name"`
-	LastName  string `json:"last_name"`
-	Username  string `json:"username"`
-	IsBot     bool   `json:"is_bot"`
-}
-
-type maxRecipient struct {
-	ChatID   int64  `json:"chat_id"`
-	ChatType string `json:"chat_type"`
-	UserID   int64  `json:"user_id"`
-}
-
-type maxMessageBody struct {
-	Text        string           `json:"text"`
-	Attachments []maxAttachment  `json:"attachments"`
-}
-
-type maxAttachment struct {
-	Type    string          `json:"type"`
-	Payload json.RawMessage `json:"payload"`
-}
-
-type maxAttachmentURL struct {
-	URL string `json:"url"`
-}
-
-func (b *Bridge) maxRequest(method, path string, query url.Values, body any) ([]byte, error) {
-	if b.MAXToken == "" {
-		return nil, fmt.Errorf("MAX_TOKEN не задан")
-	}
-	reqURL := maxAPIBase + path
-	if len(query) > 0 {
-		reqURL += "?" + query.Encode()
-	}
-	var bodyReader io.Reader
-	if body != nil {
-		data, err := json.Marshal(body)
-		if err != nil {
-			return nil, err
-		}
-		bodyReader = bytes.NewReader(data)
-	}
-	req, err := http.NewRequest(method, reqURL, bodyReader)
-	if err != nil {
-		return nil, err
-	}
-	req.Header.Set("Authorization", b.MAXToken)
-	if body != nil {
-		req.Header.Set("Content-Type", "application/json")
-	}
-	resp, err := http.DefaultClient.Do(req)
-	if err != nil {
-		return nil, err
-	}
-	defer resp.Body.Close()
-	respBody, err := io.ReadAll(resp.Body)
-	if err != nil {
-		return nil, err
-	}
-	if resp.StatusCode < 200 || resp.StatusCode >= 300 {
-		return nil, fmt.Errorf("MAX API %s %s: %d %s", method, path, resp.StatusCode, string(respBody))
-	}
-	return respBody, nil
-}
-
-func (b *Bridge) SendToMAX(chatID int64, text string) error {
-	query := url.Values{"chat_id": {strconv.FormatInt(chatID, 10)}}
-	_, err := b.maxRequest(http.MethodPost, "/messages", query, map[string]any{"text": text})
-	return err
-}
-
-type maxUploadURLResponse struct {
-	URL   string `json:"url"`
-	Token string `json:"token"`
-}
-
-// SendVideoFileToMAX загружает локальный файл как video и отправляет в чат.
-func (b *Bridge) SendVideoFileToMAX(chatID int64, filePath, text string) error {
-	query := url.Values{"type": {"video"}}
-	data, err := b.maxRequest(http.MethodPost, "/uploads", query, nil)
-	if err != nil {
-		return err
-	}
-	var up maxUploadURLResponse
-	if err := json.Unmarshal(data, &up); err != nil {
-		return err
-	}
-	if up.URL == "" || up.Token == "" {
-		return fmt.Errorf("MAX /uploads: пустой url или token: %s", string(data))
-	}
-
-	if err := b.uploadFileToMAXURL(up.URL, filePath); err != nil {
-		return err
-	}
-
-	body := map[string]any{
-		"text": text,
-		"attachments": []map[string]any{
-			{
-				"type": "video",
-				"payload": map[string]string{
-					"token": up.Token,
-				},
-			},
-		},
-	}
-	msgQuery := url.Values{"chat_id": {strconv.FormatInt(chatID, 10)}}
-
-	// После загрузки MAX может ещё обрабатывать файл — повторяем при attachment.not.ready
-	var lastErr error
-	for attempt := 0; attempt < 8; attempt++ {
-		if attempt > 0 {
-			wait := time.Duration(attempt*attempt) * time.Second
-			log.Printf("[MAX] ожидание обработки видео %s…", wait)
-			time.Sleep(wait)
-		}
-		_, lastErr = b.maxRequest(http.MethodPost, "/messages", msgQuery, body)
-		if lastErr == nil {
-			return nil
-		}
-		if !strings.Contains(lastErr.Error(), "attachment.not.ready") &&
-			!strings.Contains(lastErr.Error(), "not.processed") {
-			return lastErr
-		}
-	}
-	return lastErr
-}
-
-func (b *Bridge) uploadFileToMAXURL(uploadURL, filePath string) error {
-	f, err := os.Open(filePath)
-	if err != nil {
-		return err
-	}
-	defer f.Close()
-
-	pr, pw := io.Pipe()
-	w := multipart.NewWriter(pw)
-	errCh := make(chan error, 1)
-	go func() {
-		defer pw.Close()
-		part, err := w.CreateFormFile("data", filepath.Base(filePath))
-		if err != nil {
-			errCh <- err
-			_ = pw.CloseWithError(err)
-			return
-		}
-		if _, err := io.Copy(part, f); err != nil {
-			errCh <- err
-			_ = pw.CloseWithError(err)
-			return
-		}
-		errCh <- w.Close()
-	}()
-
-	req, err := http.NewRequest(http.MethodPost, uploadURL, pr)
-	if err != nil {
-		_ = pr.Close()
-		return err
-	}
-	req.Header.Set("Content-Type", w.FormDataContentType())
-	if b.MAXToken != "" {
-		req.Header.Set("Authorization", b.MAXToken)
-	}
-
-	resp, err := http.DefaultClient.Do(req)
-	writeErr := <-errCh
-	if err != nil {
-		return err
-	}
-	defer resp.Body.Close()
-	respBody, _ := io.ReadAll(resp.Body)
-	if writeErr != nil {
-		return writeErr
-	}
-	if resp.StatusCode < 200 || resp.StatusCode >= 300 {
-		return fmt.Errorf("MAX upload file: %d %s", resp.StatusCode, string(respBody))
-	}
-	return nil
-}
-
-func (b *Bridge) GetMAXUpdates(marker *int64, timeout int) (*maxUpdatesResponse, error) {
-	query := url.Values{
-		"limit":  {"100"},
-		"types":  {"message_created"},
-	}
-	if timeout > 0 {
-		query.Set("timeout", strconv.Itoa(timeout))
-	}
-	if marker != nil {
-		query.Set("marker", strconv.FormatInt(*marker, 10))
-	}
-	data, err := b.maxRequest(http.MethodGet, "/updates", query, nil)
-	if err != nil {
-		return nil, err
-	}
-	var resp maxUpdatesResponse
-	if err := json.Unmarshal(data, &resp); err != nil {
-		return nil, err
-	}
-	return &resp, nil
-}
-
-func (b *Bridge) SubscribeMAXWebhook(webhookURL, secret string) error {
-	body := map[string]any{
-		"url":          webhookURL,
-		"update_types": []string{"message_created"},
-	}
-	if secret != "" {
-		body["secret"] = secret
-	}
-	_, err := b.maxRequest(http.MethodPost, "/subscriptions", nil, body)
-	return err
-}
-
-func maxUserDisplayName(u *maxUser) string {
-	if u == nil {
-		return "unknown"
-	}
-	name := u.FirstName
-	if u.LastName != "" {
-		if name != "" {
-			name += " "
-		}
-		name += u.LastName
-	}
-	if name == "" && u.Username != "" {
-		name = u.Username
-	}
-	if name == "" {
-		return strconv.FormatInt(u.UserID, 10)
-	}
-	return name
-}
-
-func maxMessageChatID(msg *maxMessage) int64 {
-	if msg == nil || msg.Recipient == nil {
-		return 0
-	}
-	return msg.Recipient.ChatID
-}
-
-func maxExtractMediaURLs(msg *maxMessage) []string {
-	if msg == nil || msg.Body == nil {
-		return nil
-	}
-	var urls []string
-	for _, att := range msg.Body.Attachments {
-		switch att.Type {
-		case "image", "video", "audio", "file", "sticker":
-			var payload maxAttachmentURL
-			if err := json.Unmarshal(att.Payload, &payload); err == nil && payload.URL != "" {
-				urls = append(urls, payload.URL)
-			}
-		}
-	}
-	return urls
-}
@@ -1,114 +0,0 @@
-package main
-
-import (
-	"encoding/json"
-	"log"
-	"net/http"
-	"os"
-	"strconv"
-	"strings"
-)
-
-func (b *Bridge) StartMAXListener(forward func(text string, sender string, media []string)) {
-	if b.MAXToken == "" {
-		log.Println("MAX_TOKEN не задан, MAX listener не запущен")
-		return
-	}
-	if strings.EqualFold(os.Getenv("MAX_USE_WEBHOOK"), "true") {
-		log.Println("MAX: режим webhook (long polling отключён)")
-		return
-	}
-	go b.runMAXLongPoll(forward)
-}
-
-func (b *Bridge) runMAXLongPoll(forward func(text string, sender string, media []string)) {
-	log.Println("[MAX] Long polling запущен")
-	var marker *int64
-	filterChatID := os.Getenv("MAX_CHAT_ID")
-	for {
-		resp, err := b.GetMAXUpdates(marker, 30)
-		if err != nil {
-			log.Printf("[MAX] ошибка получения updates: %v", err)
-			continue
-		}
-		marker = resp.Marker
-		for _, upd := range resp.Updates {
-			if upd.UpdateType != "message_created" || upd.Message == nil {
-				continue
-			}
-			b.handleMAXMessage(upd.Message, filterChatID, forward)
-		}
-	}
-}
-
-func (b *Bridge) handleMAXMessage(msg *maxMessage, filterChatID string, forward func(text string, sender string, media []string)) {
-	if msg.Sender != nil && msg.Sender.IsBot {
-		return
-	}
-	chatID := maxMessageChatID(msg)
-	if filterChatID != "" {
-		want, err := strconv.ParseInt(filterChatID, 10, 64)
-		if err == nil && chatID != want {
-			return
-		}
-	}
-	text := ""
-	if msg.Body != nil {
-		text = msg.Body.Text
-	}
-	media := maxExtractMediaURLs(msg)
-	sender := maxUserDisplayName(msg.Sender)
-	log.Printf("[MAX] %s: %s", sender, text)
-	forward(text, sender, media)
-}
-
-func (b *Bridge) RegisterMAXWebhookHandler(forward func(text string, sender string, media []string)) {
-	secret := os.Getenv("MAX_WEBHOOK_SECRET")
-	filterChatID := os.Getenv("MAX_CHAT_ID")
-
-	http.HandleFunc("/max/webhook", func(w http.ResponseWriter, r *http.Request) {
-		if r.Method != http.MethodPost {
-			http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
-			return
-		}
-		if secret != "" && r.Header.Get("X-Max-Bot-Api-Secret") != secret {
-			http.Error(w, "Forbidden", http.StatusForbidden)
-			return
-		}
-		var upd maxUpdate
-		if err := json.NewDecoder(r.Body).Decode(&upd); err != nil {
-			http.Error(w, "Bad request", http.StatusBadRequest)
-			return
-		}
-		if upd.UpdateType == "message_created" && upd.Message != nil {
-			b.handleMAXMessage(upd.Message, filterChatID, forward)
-		}
-		w.WriteHeader(http.StatusOK)
-		w.Write([]byte("ok"))
-	})
-}
-
-func (b *Bridge) SetupMAXWebhook() {
-	if b.MAXToken == "" {
-		return
-	}
-	if !strings.EqualFold(os.Getenv("MAX_USE_WEBHOOK"), "true") {
-		return
-	}
-	publicURL := strings.TrimSuffix(os.Getenv("PUBLIC_URL"), "/")
-	if publicURL == "" {
-		log.Println("MAX: MAX_USE_WEBHOOK=true, но PUBLIC_URL не задан — webhook не зарегистрирован")
-		return
-	}
-	if !strings.HasPrefix(publicURL, "https://") {
-		log.Println("MAX: для webhook нужен HTTPS в PUBLIC_URL (требование MAX API)")
-		return
-	}
-	webhookURL := publicURL + "/max/webhook"
-	secret := os.Getenv("MAX_WEBHOOK_SECRET")
-	if err := b.SubscribeMAXWebhook(webhookURL, secret); err != nil {
-		log.Printf("[MAX] ошибка регистрации webhook: %v", err)
-		return
-	}
-	log.Printf("[MAX] webhook зарегистрирован: %s", webhookURL)
-}
@@ -1,90 +1,234 @@
 package main

 import (
+	"encoding/json"
+	"fmt"
 	"log"
+	"sort"
+	"strings"

 	tgbotapi "github.com/go-telegram-bot-api/telegram-bot-api/v5"
 )

-func (b *Bridge) StartTelegramListener(forward func(text string, sender string, media []string)) {
-	u := tgbotapi.NewUpdate(0)
-	u.Timeout = 60
+type telegramReactionType struct {
+	Type          string `json:"type"`
+	Emoji         string `json:"emoji,omitempty"`
+	CustomEmojiID string `json:"custom_emoji_id,omitempty"`
+}

-	updates := b.Telegram.GetUpdatesChan(u)
+type telegramMessageReactionUpdated struct {
+	Chat        tgbotapi.Chat          `json:"chat"`
+	MessageID   int                    `json:"message_id"`
+	OldReaction []telegramReactionType `json:"old_reaction"`
+	NewReaction []telegramReactionType `json:"new_reaction"`
+}

+type telegramRawUpdate struct {
+	UpdateID        int                             `json:"update_id"`
+	Message         *tgbotapi.Message               `json:"message,omitempty"`
+	MessageReaction *telegramMessageReactionUpdated `json:"message_reaction,omitempty"`
+}
+
+func (b *Bridge) StartTelegramListener(
+	forward func(text string, sender string, media []string, messageID int, chatID int64),
+	onReactionAdded func(chatID int64, messageID int, reaction string),
+) {
 	go func() {
-		for update := range updates {
-			if update.Message == nil {
+		offset := 0
+		for {
+			params := tgbotapi.Params{}
+			params.AddNonZero("offset", offset)
+			params.AddNonZero("timeout", 60)
+			_ = params.AddInterface("allowed_updates", []string{"message", "message_reaction"})
+
+			resp, err := b.Telegram.MakeRequest("getUpdates", params)
+			if err != nil {
+				log.Printf("[Telegram] getUpdates error: %v", err)
 				continue
 			}
-			// Формируем строку с именем и username пользователя
-			userInfo := update.Message.From.FirstName
-			if update.Message.From.UserName != "" {
-				userInfo += " " + update.Message.From.UserName
-			}
-			// Собираем медиа URL'ы
-			media := make([]string, 0)
-
-			getFileURL := func(fileID string) (string, error) {
-				file, err := b.Telegram.GetFile(tgbotapi.FileConfig{FileID: fileID})
-				if err != nil {
-					log.Printf("[Telegram] GetFile error: %v", err)
-					return "", err
-				}
-				if proxyURL := b.GetTelegramFileProxyURL(file.FilePath); proxyURL != "" {
-					log.Printf("[Telegram] медиа: прокси-ссылка для %s", file.FilePath)
-					return proxyURL, nil
-				}
-				log.Printf("[Telegram] медиа: прямая ссылка (PUBLIC_URL/MEDIA_PROXY_SECRET не заданы?) для %s", file.FilePath)
-				return b.GetTelegramFileDirectURL(file.FilePath), nil
+			if !resp.Ok {
+				log.Printf("[Telegram] getUpdates response error: %s", resp.Description)
+				continue
 			}

-			// Фото (берём самое большое)
-			if len(update.Message.Photo) > 0 {
-				photo := update.Message.Photo[len(update.Message.Photo)-1]
-				if url, err := getFileURL(photo.FileID); err == nil {
-					media = append(media, url)
-				}
+			var rawItems []json.RawMessage
+			if err := json.Unmarshal(resp.Result, &rawItems); err != nil {
+				log.Printf("[Telegram] cannot decode updates: %v", err)
+				continue
 			}

-			// Document
-			if update.Message.Document != nil {
-				if url, err := getFileURL(update.Message.Document.FileID); err == nil {
-					media = append(media, url)
+			for _, raw := range rawItems {
+				var update telegramRawUpdate
+				if err := json.Unmarshal(raw, &update); err != nil {
+					log.Printf("[Telegram] cannot decode update item: %v", err)
+					continue
+				}
+				updateKinds := detectTelegramUpdateKinds(raw)
+				log.Printf(
+					"[Telegram][diag] update_id=%d kinds=%s has_message=%t has_message_reaction=%t",
+					update.UpdateID,
+					strings.Join(updateKinds, ","),
+					update.Message != nil,
+					update.MessageReaction != nil,
+				)
+				offset = update.UpdateID + 1
+
+				if update.Message != nil {
+					text, media := b.telegramMessagePayload(update.Message)
+					userInfo := "unknown"
+					if update.Message.From != nil {
+						userInfo = update.Message.From.FirstName
+						if update.Message.From.UserName != "" {
+							userInfo += " " + update.Message.From.UserName
+						}
+					}
+					log.Printf("[Telegram] %s: %s", userInfo, text)
+					forward(text, userInfo, media, update.Message.MessageID, update.Message.Chat.ID)
+				}
+
+				if update.MessageReaction != nil {
+					log.Printf(
+						"[Telegram][diag] message_reaction chat_id=%d message_id=%d old=%s new=%s",
+						update.MessageReaction.Chat.ID,
+						update.MessageReaction.MessageID,
+						formatTelegramReactions(update.MessageReaction.OldReaction),
+						formatTelegramReactions(update.MessageReaction.NewReaction),
+					)
+					added := addedReactions(update.MessageReaction.OldReaction, update.MessageReaction.NewReaction)
+					if len(added) == 0 {
+						log.Printf(
+							"[Telegram][diag] message_reaction chat_id=%d message_id=%d has no added reactions",
+							update.MessageReaction.Chat.ID,
+							update.MessageReaction.MessageID,
+						)
+					}
+					for _, reaction := range added {
+						log.Printf(
+							"[Telegram][diag] added reaction chat_id=%d message_id=%d reaction=%q",
+							update.MessageReaction.Chat.ID,
+							update.MessageReaction.MessageID,
+							reaction,
+						)
+						onReactionAdded(update.MessageReaction.Chat.ID, update.MessageReaction.MessageID, reaction)
+					}
 				}
 			}
-
-			// Video
-			if update.Message.Video != nil {
-				if url, err := getFileURL(update.Message.Video.FileID); err == nil {
-					media = append(media, url)
-				}
-			}
-
-			// Audio
-			if update.Message.Audio != nil {
-				if url, err := getFileURL(update.Message.Audio.FileID); err == nil {
-					media = append(media, url)
-				}
-			}
-
-			// Voice
-			if update.Message.Voice != nil {
-				if url, err := getFileURL(update.Message.Voice.FileID); err == nil {
-					media = append(media, url)
-				}
-			}
-
-			// Animation (GIF)
-			if update.Message.Animation != nil {
-				if url, err := getFileURL(update.Message.Animation.FileID); err == nil {
-					media = append(media, url)
-				}
-			}
-
-			log.Printf("[Telegram] %s: %s", userInfo, update.Message.Text)
-			// Передаём имя отправителя и медиа
-			forward(update.Message.Text, userInfo, media)
 		}
 	}()
 }
+
+func (b *Bridge) telegramMessagePayload(message *tgbotapi.Message) (string, []string) {
+	if message == nil {
+		return "", nil
+	}
+	media := make([]string, 0)
+	getFileURL := func(fileID string) (string, error) {
+		file, err := b.Telegram.GetFile(tgbotapi.FileConfig{FileID: fileID})
+		if err != nil {
+			return "", err
+		}
+		return fmt.Sprintf("https://api.telegram.org/file/bot%s/%s", b.Telegram.Token, file.FilePath), nil
+	}
+
+	if len(message.Photo) > 0 {
+		photo := message.Photo[len(message.Photo)-1]
+		if url, err := getFileURL(photo.FileID); err == nil {
+			media = append(media, url)
+		}
+	}
+	if message.Document != nil {
+		if url, err := getFileURL(message.Document.FileID); err == nil {
+			media = append(media, url)
+		}
+	}
+	if message.Video != nil {
+		if url, err := getFileURL(message.Video.FileID); err == nil {
+			media = append(media, url)
+		}
+	}
+	if message.Audio != nil {
+		if url, err := getFileURL(message.Audio.FileID); err == nil {
+			media = append(media, url)
+		}
+	}
+	if message.Voice != nil {
+		if url, err := getFileURL(message.Voice.FileID); err == nil {
+			media = append(media, url)
+		}
+	}
+	if message.Animation != nil {
+		if url, err := getFileURL(message.Animation.FileID); err == nil {
+			media = append(media, url)
+		}
+	}
+
+	return message.Text, media
+}
+
+func addedReactions(oldList, newList []telegramReactionType) []string {
+	oldSet := make(map[string]struct{}, len(oldList))
+	for _, reaction := range oldList {
+		oldSet[reactionKey(reaction)] = struct{}{}
+	}
+
+	added := make([]string, 0)
+	for _, reaction := range newList {
+		key := reactionKey(reaction)
+		if _, exists := oldSet[key]; exists {
+			continue
+		}
+		added = append(added, reactionDisplayValue(reaction))
+	}
+	return added
+}
+
+func reactionKey(reaction telegramReactionType) string {
+	switch reaction.Type {
+	case "emoji":
+		return "emoji:" + reaction.Emoji
+	case "custom_emoji":
+		return "custom_emoji:" + reaction.CustomEmojiID
+	default:
+		return reaction.Type
+	}
+}
+
+func reactionDisplayValue(reaction telegramReactionType) string {
+	if reaction.Type == "emoji" && reaction.Emoji != "" {
+		return reaction.Emoji
+	}
+	if reaction.Type == "custom_emoji" && reaction.CustomEmojiID != "" {
+		return "custom_emoji:" + reaction.CustomEmojiID
+	}
+	return reaction.Type
+}
+
+func detectTelegramUpdateKinds(raw json.RawMessage) []string {
+	var payload map[string]json.RawMessage
+	if err := json.Unmarshal(raw, &payload); err != nil {
+		return []string{"unmarshal_error"}
+	}
+	kinds := make([]string, 0, len(payload))
+	for key := range payload {
+		if key == "update_id" {
+			continue
+		}
+		kinds = append(kinds, key)
+	}
+	if len(kinds) == 0 {
+		return []string{"none"}
+	}
+	sort.Strings(kinds)
+	return kinds
+}
+
+func formatTelegramReactions(list []telegramReactionType) string {
+	if len(list) == 0 {
+		return "[]"
+	}
+	parts := make([]string, 0, len(list))
+	for _, reaction := range list {
+		parts = append(parts, reactionKey(reaction)+"="+reactionDisplayValue(reaction))
+	}
+	return "[" + strings.Join(parts, ", ") + "]"
+}
@@ -1,40 +0,0 @@
-package main
-
-import (
-	"context"
-	"log"
-	"os"
-	"strconv"
-
-	"github.com/SevereCloud/vksdk/v2/events"
-	"github.com/SevereCloud/vksdk/v2/longpoll-bot"
-)
-
-func (b *Bridge) StartVKListener(forward func(text string, sender string, media []string)) {
-	groupIDStr := os.Getenv("VK_GROUP_ID")
-	if groupIDStr == "" {
-		log.Println("VK_GROUP_ID не задана в переменных окружения")
-		return
-	}
-	groupID, err := strconv.Atoi(groupIDStr)
-	if err != nil {
-		log.Printf("Ошибка преобразования VK_GROUP_ID: %v", err)
-		return
-	}
-
-	lp, err := longpoll.NewLongPoll(b.VK, groupID)
-	if err != nil {
-		log.Printf("Ошибка создания longpoll: %v", err)
-		return
-	}
-
-	lp.MessageNew(func(_ context.Context, obj events.MessageNewObject) {
-		log.Printf("[VK] %d: %s", obj.Message.FromID, obj.Message.Text)
-		sender := "vk:" + strconv.Itoa(obj.Message.FromID)
-		if name, err := b.GetVKUserName(obj.Message.FromID); err == nil {
-			sender = name
-		}
-		forward(obj.Message.Text, sender, nil)
-	})
-	go lp.Run()
-}
@@ -1,138 +0,0 @@
-package main
-
-import (
-	"encoding/json"
-	"fmt"
-	"log"
-	"os"
-	"os/exec"
-	"path/filepath"
-	"regexp"
-	"strconv"
-	"strings"
-)
-
-const (
-	maxYouTubeDurationSec = 5 * 60
-	maxYouTubeFileBytes   = 250 * 1024 * 1024 // лимит MAX для video
-)
-
-var youtubeURLRe = regexp.MustCompile(`(?i)https?://(?:(?:www|m)\.)?(?:youtube\.com/(?:watch\?[^ \t\n]*v=|shorts/|embed/|live/)|youtu\.be/)[^\s<>"']+`)
-
-func extractYouTubeURL(text string) string {
-	m := youtubeURLRe.FindString(text)
-	if m == "" {
-		return ""
-	}
-	return strings.TrimRight(m, ".,);]!?")
-}
-
-type ytDLPInfo struct {
-	Duration float64 `json:"duration"`
-	Title    string  `json:"title"`
-	ID       string  `json:"id"`
-}
-
-func getYouTubeInfo(videoURL string) (*ytDLPInfo, error) {
-	cmd := exec.Command("yt-dlp", "--dump-json", "--no-playlist", "--no-download", videoURL)
-	out, err := cmd.Output()
-	if err != nil {
-		if ee, ok := err.(*exec.ExitError); ok {
-			return nil, fmt.Errorf("yt-dlp info: %v: %s", err, string(ee.Stderr))
-		}
-		return nil, fmt.Errorf("yt-dlp не найден или ошибка: %w", err)
-	}
-	var info ytDLPInfo
-	if err := json.Unmarshal(out, &info); err != nil {
-		return nil, err
-	}
-	return &info, nil
-}
-
-// downloadYouTubeIfShort скачивает ролик, если он короче 5 минут и уложится в лимит MAX.
-// Возвращает путь к временному файлу (caller должен удалить) или ошибку.
-func downloadYouTubeIfShort(videoURL string) (filePath string, title string, err error) {
-	info, err := getYouTubeInfo(videoURL)
-	if err != nil {
-		return "", "", err
-	}
-	if info.Duration <= 0 {
-		return "", "", fmt.Errorf("не удалось определить длительность")
-	}
-	if info.Duration > float64(maxYouTubeDurationSec) {
-		return "", "", fmt.Errorf("видео длиннее 5 минут (%.0f с)", info.Duration)
-	}
-
-	tmpDir, err := os.MkdirTemp("", "bridge-yt-*")
-	if err != nil {
-		return "", "", err
-	}
-	outTmpl := filepath.Join(tmpDir, "video.%(ext)s")
-
-	// mp4 предпочтительнее для MAX; ограничение размера 250 МБ
-	cmd := exec.Command(
-		"yt-dlp",
-		"--no-playlist",
-		"--max-filesize", strconv.Itoa(maxYouTubeFileBytes),
-		"-f", "bv*[ext=mp4]+ba[ext=m4a]/b[ext=mp4]/bv*+ba/b",
-		"--merge-output-format", "mp4",
-		"-o", outTmpl,
-		videoURL,
-	)
-	cmd.Stdout = os.Stdout
-	cmd.Stderr = os.Stderr
-	if err := cmd.Run(); err != nil {
-		_ = os.RemoveAll(tmpDir)
-		return "", "", fmt.Errorf("yt-dlp download: %w", err)
-	}
-
-	entries, err := os.ReadDir(tmpDir)
-	if err != nil || len(entries) == 0 {
-		_ = os.RemoveAll(tmpDir)
-		return "", "", fmt.Errorf("файл после скачивания не найден")
-	}
-	filePath = filepath.Join(tmpDir, entries[0].Name())
-	st, err := os.Stat(filePath)
-	if err != nil {
-		_ = os.RemoveAll(tmpDir)
-		return "", "", err
-	}
-	if st.Size() > maxYouTubeFileBytes {
-		_ = os.RemoveAll(tmpDir)
-		return "", "", fmt.Errorf("файл больше лимита MAX 250 МБ (%d)", st.Size())
-	}
-	log.Printf("[YouTube] скачано: %s (%.0f с, %d байт)", info.Title, info.Duration, st.Size())
-	return filePath, info.Title, nil
-}
-
-func cleanupYouTubeFile(filePath string) {
-	if filePath == "" {
-		return
-	}
-	_ = os.RemoveAll(filepath.Dir(filePath))
-}
-
-// SendToMAXSmart: при YouTube-ссылке и ролике < 5 мин отправляет видео-вложение, иначе текст (со ссылкой).
-func (b *Bridge) SendToMAXSmart(chatID int64, text string) error {
-	ytURL := extractYouTubeURL(text)
-	if ytURL == "" {
-		return b.SendToMAX(chatID, text)
-	}
-
-	filePath, title, err := downloadYouTubeIfShort(ytURL)
-	if err != nil {
-		log.Printf("[YouTube→MAX] не удалось скачать (%s), отправляю ссылкой: %v", ytURL, err)
-		return b.SendToMAX(chatID, text)
-	}
-	defer cleanupYouTubeFile(filePath)
-
-	caption := text
-	if title != "" && !strings.Contains(text, title) {
-		caption = text + "\n" + title
-	}
-	if err := b.SendVideoFileToMAX(chatID, filePath, caption); err != nil {
-		log.Printf("[YouTube→MAX] ошибка загрузки видео, отправляю ссылкой: %v", err)
-		return b.SendToMAX(chatID, text)
-	}
-	return nil
-}
Author	SHA1	Message	Date
Taz	6d57767344	по реакции теперь сохраняем сообщение	2026-04-22 23:27:35 +02:00
Taz	90e83bcb1d	При реакции на сообщение в Telegram, дублируется сообщение в Discord	2026-04-22 19:19:07 +02:00
Taz	d3b54c682b	Чат-бот для объединения Telegram и Discord в ROX, в отличии от основого нет ВК и сайта	2026-04-22 18:27:05 +02:00