TURN/turn-bridge
Public Access
3
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Добавлен MAX

Browse Source
This commit is contained in:
Taz
2026-06-01 19:04:04 +02:00
parent d300bc9824
commit c6091fb581
7 changed files with 388 additions and 6 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Dockerfile
+4
View File
@@ -23,6 +23,10 @@ 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=""
README.md
+20 -3
View File
@@ -1,11 +1,11 @@
# Go Chat Bridge
Мультичат-бот для объединения чатов в **Telegram**, **Discord**, **VK** и на **вашем сайте**.
Мультичат-бот для объединения чатов в **Telegram**, **Discord**, **VK**, **MAX** и на **вашем сайте**.
## Возможности
- Пересылка сообщений между Telegram, Discord, VK и сайтом
- Отображение имени отправителя в пересылаемых сообщениях (`[TG]`, `[DS]`, `[VK]`, `[SITE]`)
- Пересылка сообщений между Telegram, Discord, VK, MAX и сайтом
- Отображение имени отправителя в пересылаемых сообщениях (`[TG]`, `[DS]`, `[VK]`, `[MAX]`, `[SITE]`)
- **Медиа**: фото, документы, видео, аудио, голосовые, GIF
- В **Discord** и **Telegram** медиа отправляются как вложения (файлы)
- В **VK** и на **сайт** — ссылками на прокси (без токена бота в URL)
@@ -29,6 +29,7 @@ go mod tidy
- **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. Переменные окружения
@@ -46,6 +47,12 @@ 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=...
@@ -83,6 +90,7 @@ docker-compose up -d --build
| Путь | Описание |
|-----------|----------|
| `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 для корректного отображения и сохранения. |
## Формат сообщений в чатах
@@ -90,6 +98,7 @@ docker-compose up -d --build
- `[TG] Имя: текст` — из Telegram
- `[DS] Имя: текст` — из Discord
- `[VK] Имя: текст` — из VK
- `[MAX] Имя: текст` — из MAX
- `[SITE] Имя: текст` — с сайта
При наличии медиа к сообщению добавляются ссылки (в VK и на сайте — на прокси с расширением в конце, например `.../media/xxx/file_332.jpg`).
@@ -103,6 +112,14 @@ docker-compose up -d --build
```
Скопируйте `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`.
## Логи
При старте выводятся:
bridge.go
+3 -1
View File
@@ -59,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 {
@@ -81,6 +82,7 @@ func NewBridge(telegramToken, discordToken, vkToken string) (*Bridge, error) {
Telegram: tgBot,
Discord: dg,
VK: vk,
MAXToken: maxToken,
}, nil
}
docker-compose.yml
+4
View File
@@ -11,6 +11,10 @@ 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}"
main.go
+62 -2
View File
@@ -35,12 +35,13 @@ func main() {
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)
}
@@ -51,6 +52,7 @@ 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, media []string) {
// Собираем итоговый текст с медиа URL, если есть
@@ -85,6 +87,11 @@ func main() {
_ = bridge.SendToVK(id, "[TG] "+sender+": "+msg)
}
}
if maxChatID != "" {
if id, err := strconv.ParseInt(maxChatID, 10, 64); err == nil {
_ = bridge.SendToMAX(id, "[TG] "+sender+": "+msg)
}
}
_ = bridge.SendToSite("[TG] " + sender + ": " + msg)
case "discord":
// Для Telegram отправляем файлы, если есть, иначе текст
@@ -109,6 +116,11 @@ func main() {
_ = bridge.SendToVK(id, "[DS] "+sender+": "+msg)
}
}
if maxChatID != "" {
if id, err := strconv.ParseInt(maxChatID, 10, 64); err == nil {
_ = bridge.SendToMAX(id, "[DS] "+sender+": "+msg)
}
}
_ = bridge.SendToSite("[DS] " + sender + ": " + msg)
case "vk":
// Если когда-либо будут передаваться ссылки на медиа из VK, для TG/Discord можем тоже отправлять файлы
@@ -141,6 +153,11 @@ func main() {
}
}
// Для сайта оставляем ссылки
if maxChatID != "" {
if id, err := strconv.ParseInt(maxChatID, 10, 64); err == nil {
_ = bridge.SendToMAX(id, "[VK] "+sender+": "+msg)
}
}
_ = bridge.SendToSite("[VK] " + sender + ": " + msg)
case "site":
// Из сайта пока не принимаем ссылки на файлы, отправляем как текст
@@ -157,12 +174,55 @@ func main() {
_ = bridge.SendToVK(id, "[SITE] "+sender+": "+msg)
}
}
if maxChatID != "" {
if id, err := strconv.ParseInt(maxChatID, 10, 64); err == nil {
_ = bridge.SendToMAX(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) {
@@ -279,6 +339,6 @@ func main() {
} else {
log.Println("Медиа-прокси выключен (задайте PUBLIC_URL и MEDIA_PROXY_SECRET для включения)")
}
log.Println("Webhook listening on :8080 (/webhook, /media/)")
log.Println("Webhook listening on :8080 (/webhook, /max/webhook, /media/)")
log.Fatal(http.ListenAndServe(":8080", nil))
}
max_client.go
+181
View File
@@ -0,0 +1,181 @@
package main
import (
"bytes"
"encoding/json"
"fmt"
"io"
"net/http"
"net/url"
"strconv"
)
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]string{"text": text})
return err
}
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
+114
View File
@@ -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)
}