Добавить пересылку коротких YouTube-роликов в MAX как видео.

Co-authored-by: Cursor <cursoragent@cursor.com>

.gitignore

@@ -1 +1,2 @@
 .env
+go-chat-bridge

Dockerfile

@@ -1,10 +1,20 @@
 # Go Chat Bridge Dockerfile
 FROM golang:1.22-alpine AS builder
 WORKDIR /app
-COPY . .
+# Сначала только зависимости — этот слой кэшируется, пока не меняются go.mod/go.sum
-RUN go mod tidy && go build -o chat-bridge .
+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 .
 
 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 .
 
@@ -16,5 +26,14 @@ 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=""
 
 CMD ["./chat-bridge"]

README.md

@@ -0,0 +1,137 @@
+# Go Chat Bridge
+
+Мультичат-бот для объединения чатов в **Telegram**, **Discord**, **VK**, **MAX** и на **вашем сайте**.
+
+## Возможности
+
+- Пересылка сообщений между 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` при запуске
+- Версия и дата сборки в логах при старте
+
+## Быстрый старт
+
+### 1. Клонирование и зависимости
+
+```bash
+git clone <repo_url>
+cd turn-bridge
+go mod tidy
+```
+
+### 2. Токены и ID
+
+- **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`
+
+### 3. Переменные окружения
+
+Создайте `.env` в корне проекта (при запуске бинарника переменные подхватываются автоматически):
+
+```env
+# Обязательные
+TELEGRAM_TOKEN=...
+DISCORD_TOKEN=...
+VK_TOKEN=...
+
+# ID чатов
+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=длинная-секретная-строка
+```
+
+- **PUBLIC_URL** — базовый URL, по которому доступен этот сервис (порт 8080). По нему отдаются ссылки вида `PUBLIC_URL/media/...`.
+- **MEDIA_PROXY_SECRET** — секрет для подписи ссылок на медиа. Без него прокси отключён, в VK и на сайт пойдут прямые ссылки Telegram (с токеном бота).
+
+### 4. Запуск
+
+**Локально:**
+
+```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]` при пересылке и отдаче медиа
+
+## Лицензия
+
+MIT

bridge.go

@@ -1,12 +1,50 @@
 package main
 
 import (
+	"crypto/hmac"
+	"crypto/sha256"
+	"encoding/base64"
+	"fmt"
+	"io"
+	"mime"
+	"net/http"
+	"net/url"
+	"os"
+	"path"
 	"strconv"
-	tgbotapi "github.com/go-telegram-bot-api/telegram-bot-api/v5"
+	"strings"
-	"github.com/bwmarrin/discordgo"
+
 	"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})
@@ -21,9 +59,10 @@ type Bridge struct {
 	Telegram *tgbotapi.BotAPI
 	Discord  *discordgo.Session
 	VK       *api.VK
+	MAXToken string
 }
 
-func NewBridge(telegramToken, discordToken, vkToken string) (*Bridge, error) {
+func NewBridge(telegramToken, discordToken, vkToken, maxToken string) (*Bridge, error) {
 	// Telegram
 	tgBot, err := tgbotapi.NewBotAPI(telegramToken)
 	if err != nil {
@@ -43,28 +82,217 @@ func NewBridge(telegramToken, discordToken, vkToken string) (*Bridge, error) {
 		Telegram: tgBot,
 		Discord:  dg,
 		VK:       vk,
+		MAXToken: maxToken,
 	}, nil
 }
 
-	// Отправка сообщения в Telegram
+// signMediaToken создаёт подписанный токен для filePath (HMAC-SHA256), чтобы не светить токен бота в ссылках.
-	func (b *Bridge) SendToTelegram(chatID int64, text string) error {
+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)
 	_, err := b.Telegram.Send(msg)
 	return err
-	}
+}
 
-	// Отправка сообщения в Discord
+// Отправка сообщения в Discord
-	func (b *Bridge) SendToDiscord(channelID, text string) error {
+func (b *Bridge) SendToDiscord(channelID, text string) error {
 	_, err := b.Discord.ChannelMessageSend(channelID, text)
 	return err
-	}
+}
 
-	// Отправка сообщения в VK
+// Отправка сообщения в VK
-	func (b *Bridge) SendToVK(peerID int, text string) error {
+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
+	TempPath string
+	Mime     string
+}
+
+// DownloadFiles скачивает файлы по URL и сохраняет во временные файлы
+func (b *Bridge) DownloadFiles(urls []string) ([]DownloadedFile, error) {
+	results := make([]DownloadedFile, 0, len(urls))
+	for _, u := range urls {
+		resp, err := http.Get(u)
+		if err != nil {
+			return results, err
 		}
+		if resp.Body != nil {
+			defer resp.Body.Close()
+		}
+
+		parsed, err := url.Parse(u)
+		if err != nil {
+			return results, err
+		}
+		name := path.Base(parsed.Path)
+		if name == "" || name == "/" || name == "." {
+			name = "file"
+		}
+
+		ext := path.Ext(name)
+		pattern := "bridge_*" + ext
+
+		tmpFile, err := os.CreateTemp("", pattern)
+		if err != nil {
+			return results, err
+		}
+		_, copyErr := io.Copy(tmpFile, resp.Body)
+		closeErr := tmpFile.Close()
+		if copyErr != nil {
+			_ = os.Remove(tmpFile.Name())
+			return results, copyErr
+		}
+		if closeErr != nil {
+			_ = os.Remove(tmpFile.Name())
+			return results, closeErr
+		}
+
+		// Try to determine mime: header -> by extension -> sniff file
+		contentType := resp.Header.Get("Content-Type")
+		if contentType == "" || contentType == "application/octet-stream" {
+			if m := mime.TypeByExtension(ext); m != "" {
+				contentType = m
+			}
+		}
+		if contentType == "" || contentType == "application/octet-stream" {
+			if f2, err := os.Open(tmpFile.Name()); err == nil {
+				buf := make([]byte, 512)
+				n, _ := f2.Read(buf)
+				_ = f2.Close()
+				if n > 0 {
+					contentType = http.DetectContentType(buf[:n])
+				}
+			}
+		}
+
+		results = append(results, DownloadedFile{FileName: name, TempPath: tmpFile.Name(), Mime: contentType})
+	}
+	return results, nil
+}
+
+// CleanupFiles удаляет временные файлы
+func (b *Bridge) CleanupFiles(files []DownloadedFile) {
+	for _, f := range files {
+		_ = os.Remove(f.TempPath)
+	}
+}
+
+// SendFilesToDiscord отправляет один или несколько файлов в Discord канал
+func (b *Bridge) SendFilesToDiscord(channelID string, files []DownloadedFile, content string) error {
+	dgFiles := make([]*discordgo.File, 0, len(files))
+	openFiles := make([]*os.File, 0, len(files))
+	for _, f := range files {
+		fh, err := os.Open(f.TempPath)
+		if err != nil {
+			for _, of := range openFiles {
+				_ = of.Close()
+			}
+			return err
+		}
+		openFiles = append(openFiles, fh)
+		dgFiles = append(dgFiles, &discordgo.File{Name: f.FileName, Reader: fh})
+	}
+	_, err := b.Discord.ChannelMessageSendComplex(channelID, &discordgo.MessageSend{Content: content, Files: dgFiles})
+	for _, of := range openFiles {
+		_ = of.Close()
+	}
+	return err
+}
+
+// SendFilesToTelegram отправляет файлы как документы, caption добавляется только к первому
+func (b *Bridge) SendFilesToTelegram(chatID int64, files []DownloadedFile, caption string) error {
+	for i, f := range files {
+		fh, err := os.Open(f.TempPath)
+		if err != nil {
+			return err
+		}
+		var sendErr error
+		if strings.HasPrefix(f.Mime, "image/") {
+			media := tgbotapi.NewPhoto(chatID, tgbotapi.FileReader{Name: f.FileName, Reader: fh})
+			if i == 0 && caption != "" {
+				media.Caption = caption
+			}
+			_, sendErr = b.Telegram.Send(media)
+		} else if strings.HasPrefix(f.Mime, "video/") {
+			media := tgbotapi.NewVideo(chatID, tgbotapi.FileReader{Name: f.FileName, Reader: fh})
+			if i == 0 && caption != "" {
+				media.Caption = caption
+			}
+			_, sendErr = b.Telegram.Send(media)
+		} else {
+			media := tgbotapi.NewDocument(chatID, tgbotapi.FileReader{Name: f.FileName, Reader: fh})
+			if i == 0 && caption != "" {
+				media.Caption = caption
+			}
+			_, sendErr = b.Telegram.Send(media)
+		}
+		closeErr := fh.Close()
+		if sendErr != nil {
+			return sendErr
+		}
+		if closeErr != nil {
+			return closeErr
+		}
+	}
+	return nil
+}

discord_listener.go

@@ -2,16 +2,29 @@ package main
 
 import (
 	"log"
+
 	"github.com/bwmarrin/discordgo"
 )
 
-func (b *Bridge) StartDiscordListener(forward func(text string, from string)) {
+func (b *Bridge) StartDiscordListener(channelID string, forward func(text string, sender string, media []string)) {
 	b.Discord.AddHandler(func(s *discordgo.Session, m *discordgo.MessageCreate) {
+		// Игнорируем сообщения от ботов
 		if m.Author.Bot {
 			return
 		}
+		// Игнорируем сообщения не из нужного канала
+		if channelID != "" && m.ChannelID != channelID {
+			return
+		}
+		// Собираем URL вложений
+		media := make([]string, 0)
+		for _, a := range m.Attachments {
+			if a.URL != "" {
+				media = append(media, a.URL)
+			}
+		}
 		log.Printf("[Discord] %s: %s", m.Author.Username, m.Content)
-		forward(m.Content, m.Author.Username)
+		forward(m.Content, m.Author.Username, media)
 	})
 	_ = b.Discord.Open()
 }

docker-compose.yml

@@ -11,4 +11,15 @@ services:
       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}"
     restart: unless-stopped
+    ports:
+      - "8080:8080"

go.mod

@@ -10,6 +10,7 @@ require (
 
 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

go.sum

@@ -9,6 +9,8 @@ github.com/go-telegram-bot-api/telegram-bot-api/v5 v5.5.1/go.mod h1:A2S0CWkNylc2
 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=

main.go

@@ -1,23 +1,47 @@
 package main
 
 import (
+	"encoding/json"
+	"io"
 	"log"
+	"net/http"
 	"os"
+	"path"
+	"path/filepath"
 	"strconv"
+	"strings"
+
+	"github.com/joho/godotenv"
+)
+
+// Заполняются при сборке: go build -ldflags "-X main.Version=... -X main.BuildDate=..."
+var (
+	Version   = "dev"
+	BuildDate = "unknown"
 )
 
 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")
 	}
 
- 	bridge, err := NewBridge(telegramToken, discordToken, vkToken)
+	bridge, err := NewBridge(telegramToken, discordToken, vkToken, maxToken)
 	if err != nil {
 		log.Fatalf("Ошибка инициализации Bridge: %v", err)
 	}
@@ -28,46 +52,293 @@ func main() {
 	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
 
-		forward := func(text string, from string, sender string) {
+	forward := func(text string, from string, sender string, media []string) {
-			log.Printf("[Bridge] Пересылка сообщения от %s (%s): %s", from, sender, text)
+		// Собираем итоговый текст с медиа URL, если есть
+		msg := text
+		if len(media) > 0 {
+			if msg != "" {
+				msg += "\n"
+			}
+			msg += strings.Join(media, "\n")
+		}
+		log.Printf("[Bridge] Пересылка сообщения от %s (%s): %s", from, sender, msg)
 
 		switch from {
 		case "telegram":
+			// Для Discord отправляем файлы, если есть, иначе текст
 			if discordChannelID != "" {
-					_ = bridge.SendToDiscord(discordChannelID, "[TG] "+sender+": "+text)
+				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)
+				}
+			}
+			// Для VK и сайта оставляем ссылки
 			if vkPeerID != "" {
 				if id, err := strconv.Atoi(vkPeerID); err == nil {
-						_ = bridge.SendToVK(id, "[TG] "+sender+": "+text)
+					_ = bridge.SendToVK(id, "[TG] "+sender+": "+msg)
 				}
 			}
+			if maxChatID != "" {
+				if id, err := strconv.ParseInt(maxChatID, 10, 64); err == nil {
+					_ = bridge.SendToMAXSmart(id, "[TG] "+sender+": "+msg)
+				}
+			}
+			_ = bridge.SendToSite("[TG] " + sender + ": " + msg)
 		case "discord":
+			// Для Telegram отправляем файлы, если есть, иначе текст
 			if telegramChatID != "" {
 				if id, err := strconv.ParseInt(telegramChatID, 10, 64); err == nil {
-						_ = bridge.SendToTelegram(id, "[DS] "+sender+": "+text)
+					if len(media) > 0 {
+						files, derr := bridge.DownloadFiles(media)
+						if derr == nil && len(files) > 0 {
+							_ = bridge.SendFilesToTelegram(id, files, "[DS] "+sender+": "+text)
+							bridge.CleanupFiles(files)
+						} else {
+							_ = bridge.SendToTelegram(id, "[DS] "+sender+": "+msg)
+						}
+					} else {
+						_ = bridge.SendToTelegram(id, "[DS] "+sender+": "+msg)
+					}
+				}
+			}
+			// Для 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, "[DS] "+sender+": "+text)
+					_ = bridge.SendToVK(id, "[MAX] "+sender+": "+msg)
 				}
 			}
-			case "vk":
+			_ = bridge.SendToSite("[MAX] " + sender + ": " + msg)
-				if telegramChatID != "" {
-					if id, err := strconv.ParseInt(telegramChatID, 10, 64); err == nil {
-						_ = bridge.SendToTelegram(id, "[VK] "+sender+": "+text)
-					}
-				}
-				if discordChannelID != "" {
-					_ = bridge.SendToDiscord(discordChannelID, "[VK] "+sender+": "+text)
-				}
 		}
 	}
 
-		bridge.StartTelegramListener(func(text, sender string) { forward(text, "telegram", sender) })
+	bridge.StartTelegramListener(func(text string, sender string, media []string) { forward(text, "telegram", sender, media) })
-		bridge.StartDiscordListener(func(text, sender string) { forward(text, "discord", sender) })
+	bridge.StartDiscordListener(discordChannelID, func(text string, sender string, media []string) { forward(text, "discord", sender, media) })
-		bridge.StartVKListener(func(text, sender string) { forward(text, "vk", sender) })
+	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()
 
- 	select {} // Блокируем main, чтобы слушатели работали
+	// Прокси медиа 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] + "..."
+			}
+			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)
+				return
+			}
+			if req.Key != apiKey {
+				http.Error(w, "Forbidden", http.StatusForbidden)
+				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"))
+	})
+
+	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))
 }

max_client.go

@@ -0,0 +1,296 @@
+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
+}

max_listener.go

@@ -0,0 +1,114 @@
+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)
+}

telegram_listener.go

@@ -2,10 +2,11 @@ package main
 
 import (
 	"log"
+
 	tgbotapi "github.com/go-telegram-bot-api/telegram-bot-api/v5"
 )
 
-func (b *Bridge) StartTelegramListener(forward func(text string, from string)) {
+func (b *Bridge) StartTelegramListener(forward func(text string, sender string, media []string)) {
 	u := tgbotapi.NewUpdate(0)
 	u.Timeout = 60
 
@@ -16,8 +17,74 @@ func (b *Bridge) StartTelegramListener(forward func(text string, from string)) {
 			if update.Message == nil {
 				continue
 			}
-			log.Printf("[Telegram] %s: %s", update.Message.From.UserName, update.Message.Text)
+			// Формируем строку с именем и username пользователя
-			forward(update.Message.Text, update.Message.From.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 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)
+				}
+			}
+
+			// Document
+			if update.Message.Document != nil {
+				if url, err := getFileURL(update.Message.Document.FileID); err == nil {
+					media = append(media, url)
+				}
+			}
+
+			// 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)
 		}
 	}()
 }

vk_listener.go

@@ -1,15 +1,16 @@
 package main
 
 import (
+	"context"
 	"log"
 	"os"
 	"strconv"
-	"context"
+
 	"github.com/SevereCloud/vksdk/v2/events"
 	"github.com/SevereCloud/vksdk/v2/longpoll-bot"
 )
 
-func (b *Bridge) StartVKListener(forward func(text string, from string)) {
+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 не задана в переменных окружения")
@@ -33,7 +34,7 @@ func (b *Bridge) StartVKListener(forward func(text string, from string)) {
 		if name, err := b.GetVKUserName(obj.Message.FromID); err == nil {
 			sender = name
 		}
-		forward(obj.Message.Text, sender)
+		forward(obj.Message.Text, sender, nil)
 	})
 	go lp.Run()
 }

youtube.go

@@ -0,0 +1,138 @@
+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
+}