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

Dockerfile

@@ -11,10 +11,9 @@ 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 DISCORD_REACTION_CHANNEL_ID=""
-ENV VK_GROUP_ID=""
+ENV TELEGRAM_DUPLICATE_REACTION="✍️"
 
 CMD ["./chat-bridge"]

README.md

@@ -0,0 +1,69 @@
+# Go Chat Bridge
+
+Мультичат-бот для объединения Telegram и Discord.
+
+## Возможности
+- Пересылка сообщений между Telegram и Discord
+- Отображение имени отправителя в пересылаемых сообщениях
+- Поддержка медиафайлов (изображения, видео, документы)
+
+## Быстрый старт
+
+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 .
+   ```
+
+## Формат пересылаемых сообщений
+
+- `[TG] user: текст` — из Telegram
+- `[DS] user: текст` — из Discord
+
+## Пример .env
+
+Создайте файл `.env` в корне проекта и заполните:
+
+```env
+TELEGRAM_TOKEN=your_telegram_token
+DISCORD_TOKEN=your_discord_token
+TELEGRAM_CHAT_ID=-1001234567890
+DISCORD_CHANNEL_ID=123456789012345678
+DISCORD_REACTION_CHANNEL_ID=123456789012345679
+TELEGRAM_DUPLICATE_REACTION=✍️
+```
+
+docker-compose автоматически подхватит эти переменные.
+
+## Дублирование по реакции Telegram
+
+Если у Telegram-сообщения добавлена реакция, указанная в `TELEGRAM_DUPLICATE_REACTION` (по умолчанию `✍️`), то это сообщение дополнительно отправляется в `DISCORD_REACTION_CHANNEL_ID` помимо основного `DISCORD_CHANNEL_ID`.
+## TODO
+- Поддержка вложений и файлов
+- Админ-команды
+- Логирование событий
+
+## Лицензия
+MIT
+
+

bridge.go

@@ -1,29 +1,25 @@
 package main
 
 import (
-	"strconv"
+	"io"
-	tgbotapi "github.com/go-telegram-bot-api/telegram-bot-api/v5"
+	"mime"
-	"github.com/bwmarrin/discordgo"
+	"net/http"
-	"github.com/SevereCloud/vksdk/v2/api"
+	"net/url"
-)
+	"os"
+	"path"
+	"strings"
 
-// Получить имя пользователя VK по id
+	"github.com/bwmarrin/discordgo"
-func (b *Bridge) GetVKUserName(userID int) (string, error) {
+	tgbotapi "github.com/go-telegram-bot-api/telegram-bot-api/v5"
-	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
 }
 
-func NewBridge(telegramToken, discordToken, vkToken string) (*Bridge, error) {
+func NewBridge(telegramToken, discordToken string) (*Bridge, error) {
 	// Telegram
 	tgBot, err := tgbotapi.NewBotAPI(telegramToken)
 	if err != nil {
@@ -36,35 +32,157 @@ func NewBridge(telegramToken, discordToken, vkToken string) (*Bridge, error) {
 		return nil, err
 	}
 
-	// VK
-	vk := api.NewVK(vkToken)
-
 	return &Bridge{
 		Telegram: tgBot,
 		Discord:  dg,
-		VK:       vk,
 	}, nil
 }
 
-	// Отправка сообщения в Telegram
+// Отправка сообщения в Telegram
-	func (b *Bridge) SendToTelegram(chatID int64, text string) error {
+func (b *Bridge) SendToTelegram(chatID int64, text string) error {
-		msg := tgbotapi.NewMessage(chatID, text)
+	msg := tgbotapi.NewMessage(chatID, text)
-		_, err := b.Telegram.Send(msg)
+	_, err := b.Telegram.Send(msg)
-		return err
+	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)
+	_, err := b.Discord.ChannelMessageSend(channelID, text)
-		return err
+	return err
-	}
+}
 
-	// Отправка сообщения в VK
+// Загруженный файл на диск для пересылки как вложение
-	func (b *Bridge) SendToVK(peerID int, text string) error {
+type DownloadedFile struct {
-		_, err := b.VK.MessagesSend(api.Params{
+	FileName string
-			"peer_id": peerID,
+	TempPath string
-			"message": text,
+	Mime     string
-			"random_id": 0,
+}
-		})
+
-		return err
+// 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

@@ -1,14 +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}"
+      DISCORD_REACTION_CHANNEL_ID: "${DISCORD_REACTION_CHANNEL_ID}"
-      VK_GROUP_ID: "${VK_GROUP_ID}"
+      TELEGRAM_DUPLICATE_REACTION: "${TELEGRAM_DUPLICATE_REACTION}"
     restart: unless-stopped

go.mod

@@ -3,17 +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/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
 )

go.sum

@@ -1,24 +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/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=
@@ -26,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=

main.go

@@ -4,70 +4,169 @@ import (
 	"log"
 	"os"
 	"strconv"
+	"strings"
+	"sync"
 )
 
+type telegramMessageCacheItem struct {
+	Text   string
+	Sender string
+	Media  []string
+}
+
 func main() {
- 	log.Println("Go Chat Bridge запущен.")
+	log.Println("Go Chat Bridge запущен.")
 
- 	telegramToken := os.Getenv("TELEGRAM_TOKEN")
+	telegramToken := os.Getenv("TELEGRAM_TOKEN")
- 	discordToken := os.Getenv("DISCORD_TOKEN")
+	discordToken := os.Getenv("DISCORD_TOKEN")
- 	vkToken := os.Getenv("VK_TOKEN")
 
- 	if telegramToken == "" || discordToken == "" || vkToken == "" {
+	if telegramToken == "" || discordToken == "" {
- 		log.Fatal("Необходимо задать переменные окружения TELEGRAM_TOKEN, DISCORD_TOKEN, VK_TOKEN")
+		log.Fatal("Необходимо задать переменные окружения TELEGRAM_TOKEN, DISCORD_TOKEN")
- 	}
+	}
 
- 	bridge, err := NewBridge(telegramToken, discordToken, vkToken)
+	bridge, err := NewBridge(telegramToken, discordToken)
- 	if err != nil {
+	if err != nil {
- 		log.Fatalf("Ошибка инициализации Bridge: %v", err)
+		log.Fatalf("Ошибка инициализации Bridge: %v", err)
- 	}
+	}
 
- 	log.Println("Bridge успешно инициализирован:", bridge)
+	log.Println("Bridge успешно инициализирован:", bridge)
 
- 	// Получаем ID чатов/каналов из переменных окружения
+	// Получаем ID чатов/каналов из переменных окружения
- 	telegramChatID := os.Getenv("TELEGRAM_CHAT_ID") // int64
+	telegramChatID := strings.TrimSpace(os.Getenv("TELEGRAM_CHAT_ID"))                      // int64
- 	discordChannelID := os.Getenv("DISCORD_CHANNEL_ID") // string
+	discordChannelID := strings.TrimSpace(os.Getenv("DISCORD_CHANNEL_ID"))                  // string
- 	vkPeerID := os.Getenv("VK_PEER_ID") // int
+	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) {
+	messageCache := make(map[string]telegramMessageCacheItem)
-			log.Printf("[Bridge] Пересылка сообщения от %s (%s): %s", from, sender, text)
+	var cacheMu sync.RWMutex
 
-			switch from {
+	cacheKey := func(chatID int64, messageID int) string {
-			case "telegram":
+		return strconv.FormatInt(chatID, 10) + ":" + strconv.Itoa(messageID)
-				if discordChannelID != "" {
+	}
-					_ = bridge.SendToDiscord(discordChannelID, "[TG] "+sender+": "+text)
+
-				}
+	sendTelegramMessageToDiscord := func(channelID, sender, text, msg string, media []string) error {
-				if vkPeerID != "" {
+		if channelID == "" {
-					if id, err := strconv.Atoi(vkPeerID); err == nil {
+			return nil
-						_ = bridge.SendToVK(id, "[TG] "+sender+": "+text)
+		}
+		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 {
+			if msg != "" {
+				msg += "\n"
+			}
+			msg += strings.Join(media, "\n")
+		}
+		log.Printf("[Bridge] Пересылка сообщения от %s (%s): %s", from, sender, msg)
+
+		switch from {
+		case "telegram":
+			// Для Discord отправляем файлы, если есть, иначе текст
+			if err := sendTelegramMessageToDiscord(discordChannelID, sender, text, msg, media); err != nil {
+				log.Printf("[Bridge] failed to send telegram message to main Discord channel: %v", err)
+			}
+			cacheMu.Lock()
+			messageCache[cacheKey(sourceChatID, messageID)] = telegramMessageCacheItem{
+				Text:   text,
+				Sender: sender,
+				Media:  append([]string(nil), media...),
+			}
+			cacheMu.Unlock()
+		case "discord":
+			// Для Telegram отправляем файлы, если есть, иначе текст
+			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, "[DS] "+sender+": "+text)
+							bridge.CleanupFiles(files)
+						} else {
+							_ = bridge.SendToTelegram(id, "[DS] "+sender+": "+msg)
+						}
+					} else {
+						_ = bridge.SendToTelegram(id, "[DS] "+sender+": "+msg)
 					}
 				}
-			case "discord":
-				if telegramChatID != "" {
-					if id, err := strconv.ParseInt(telegramChatID, 10, 64); err == nil {
-						_ = bridge.SendToTelegram(id, "[DS] "+sender+": "+text)
-					}
-				}
-				if vkPeerID != "" {
-					if id, err := strconv.Atoi(vkPeerID); err == nil {
-						_ = bridge.SendToVK(id, "[DS] "+sender+": "+text)
-					}
-				}
-			case "vk":
-				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(
-		bridge.StartDiscordListener(func(text, sender string) { forward(text, "discord", sender) })
+		func(text string, sender string, media []string, messageID int, chatID int64) {
-		bridge.StartVKListener(func(text, sender string) { forward(text, "vk", sender) })
+			forward(text, "telegram", sender, media, messageID, chatID)
+		},
+		func(chatID int64, messageID int, reaction string) {
+			if discordChannelID != "" {
+				_ = bridge.SendToDiscord(discordChannelID, "реакция поставлена")
+			}
 
- 	select {} // Блокируем main, чтобы слушатели работали
+			if discordReactionChannelID == "" {
+				log.Printf("[Bridge] reaction duplicate skipped: DISCORD_REACTION_CHANNEL_ID is empty")
+				return
+			}
+			normalizedReaction := normalizeEmoji(reaction)
+			if normalizedReaction != normalizedDuplicateReaction {
+				log.Printf("[Bridge] reaction %q does not match configured %q", reaction, telegramDuplicateReactionEmoji)
+				return
+			}
+
+			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)
+	})
+
+	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
 }

telegram_listener.go

@@ -1,23 +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, from string)) {
+type telegramReactionType struct {
-	u := tgbotapi.NewUpdate(0)
+	Type          string `json:"type"`
-	u.Timeout = 60
+	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 {
+		offset := 0
-			if update.Message == nil {
+		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
 			}
-			log.Printf("[Telegram] %s: %s", update.Message.From.UserName, update.Message.Text)
+			if !resp.Ok {
-			forward(update.Message.Text, update.Message.From.UserName)
+				log.Printf("[Telegram] getUpdates response error: %s", resp.Description)
+				continue
+			}
+
+			var rawItems []json.RawMessage
+			if err := json.Unmarshal(resp.Result, &rawItems); err != nil {
+				log.Printf("[Telegram] cannot decode updates: %v", err)
+				continue
+			}
+
+			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)
+					}
+				}
+			}
 		}
 	}()
 }
+
+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, ", ") + "]"
+}

vk_listener.go

@@ -1,39 +0,0 @@
-package main
-
-import (
-	"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)) {
-	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)
-	})
-	go lp.Run()
-}