Fix MS Teams Support

bridge/bridge.go

@@ -45,6 +45,26 @@ type Config struct {
 	*Bridge
 
 	Remote chan config.Message
+
+	// IsMessageBridged checks whether a message has already been bridged
+	// (exists in the persistent cache). Used by replay to avoid duplicates.
+	IsMessageBridged func(protocol, msgID string) bool
+
+	// GetLastSeen returns the timestamp of the last processed message for a channel.
+	// Used by replay to determine the cutoff point.
+	GetLastSeen func(channelKey string) (time.Time, bool)
+
+	// MarkMessageBridged marks a message as handled in the persistent cache.
+	// Used by bridges when they handle a message locally (e.g. posting an error
+	// notification) without routing it through the gateway, so replay won't
+	// re-process it on the next restart.
+	MarkMessageBridged func(protocol, msgID string)
+
+	// SetDeltaToken stores a Graph API delta token for a channel.
+	SetDeltaToken func(channelKey, token string)
+
+	// GetDeltaToken returns the stored Graph API delta token for a channel.
+	GetDeltaToken func(channelKey string) (string, bool)
 }
 
 // Factory is the factory function to create a bridge

bridge/config/config.go

@@ -30,6 +30,8 @@ const (
 	EventUserTyping        = "user_typing"
 	EventGetChannelMembers = "get_channel_members"
 	EventNoticeIRC         = "notice_irc"
+	EventHistoricalMapping = "historical_mapping"
+	EventReplayMessage     = "replay_message"
 )
 
 const ParentIDNotFound = "msg-parent-not-found"
@@ -155,6 +157,8 @@ type Protocol struct {
 	MediaServerDownload    string
 	MediaConvertTgs        string     // telegram
 	MediaConvertWebPToPNG  bool       // telegram
+	MessageCacheDuration   string     // general, msteams, mattermost: max age of cache entries (default "168h" = 7 days)
+	MessageCacheFile       string     // general, msteams, mattermost: persistent message ID cache file
 	MessageDelay           int        // IRC, time in millisecond to wait between messages
 	MessageFormat          string     // telegram
 	MessageLength          int        // IRC, max length of a message allowed

bridge/helper/helper.go

@@ -23,10 +23,74 @@ import (
 
 var errHttpGetNotOk = errors.New("HTTP server responded non-OK code")
 
+// ErrFileTooLarge is returned when a file exceeds the configured MediaDownloadSize.
+type ErrFileTooLarge struct {
+	Size    int64
+	MaxSize int
+}
+
+func (e *ErrFileTooLarge) Error() string {
+	return fmt.Sprintf("file too large (%d bytes, limit %d bytes)", e.Size, e.MaxSize)
+}
+
 func HttpGetNotOkError(url string, code int) error {
 	return fmt.Errorf("%w: %s returned code %d", errHttpGetNotOk, url, code)
 }
 
+// DownloadFileWithSizeCheck downloads a file, aborting if it exceeds maxSize bytes.
+// First tries an HTTP HEAD request to check Content-Length before downloading.
+// If HEAD is not supported or returns no Content-Length, falls back to a size-limited
+// download that reads at most maxSize+1 bytes to detect oversized files without
+// buffering the entire content.
+func DownloadFileWithSizeCheck(url string, maxSize int) (*[]byte, error) {
+	client := &http.Client{Timeout: time.Second * 30}
+
+	// Try HEAD first to check Content-Length without downloading.
+	headReq, err := http.NewRequest("HEAD", url, nil)
+	if err == nil {
+		if headResp, headErr := client.Do(headReq); headErr == nil {
+			headResp.Body.Close()
+			if cl := headResp.ContentLength; cl > 0 && cl > int64(maxSize) {
+				return nil, &ErrFileTooLarge{Size: cl, MaxSize: maxSize}
+			}
+		}
+	}
+
+	// Download with size limit.
+	req, err := http.NewRequest("GET", url, nil)
+	if err != nil {
+		return nil, err
+	}
+	resp, err := client.Do(req)
+	if err != nil {
+		return nil, err
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusOK {
+		return nil, HttpGetNotOkError(url, resp.StatusCode)
+	}
+
+	// Check Content-Length from GET response too.
+	if cl := resp.ContentLength; cl > 0 && cl > int64(maxSize) {
+		return nil, &ErrFileTooLarge{Size: cl, MaxSize: maxSize}
+	}
+
+	// Read up to maxSize+1 bytes. If we get more, the file is too large.
+	limited := io.LimitReader(resp.Body, int64(maxSize)+1)
+	var buf bytes.Buffer
+	n, err := io.Copy(&buf, limited)
+	if err != nil {
+		return nil, err
+	}
+	if n > int64(maxSize) {
+		return nil, &ErrFileTooLarge{Size: n, MaxSize: maxSize}
+	}
+
+	data := buf.Bytes()
+	return &data, nil
+}
+
 // DownloadFile downloads the given non-authenticated URL.
 func DownloadFile(url string) (*[]byte, error) {
 	return DownloadFileAuth(url, "")

bridge/mattermost/handlers.go

@@ -2,6 +2,8 @@ package bmattermost
 
 import (
 	"context"
+	"fmt"
+	"strings"
 
 	"github.com/matterbridge-org/matterbridge/bridge/config"
 	"github.com/matterbridge-org/matterbridge/bridge/helper"
@@ -96,6 +98,21 @@ func (b *Bmattermost) handleMatter() {
 //nolint:cyclop
 func (b *Bmattermost) handleMatterClient(messages chan *config.Message) {
 	for message := range b.mc.MessageChan {
+		// Allowlist: only process events relevant to bridging.
+		// This avoids logging noise from status_change, hello, preferences_changed, etc.
+		et := message.Raw.EventType()
+		switch et {
+		case "posted", model.WebsocketEventPostEdited, model.WebsocketEventPostDeleted:
+			// Post events: always process (join/leave come as "posted" with system message type).
+		case "typing":
+			// Typing events: only process if ShowUserTyping is enabled.
+			if !b.GetBool("ShowUserTyping") {
+				continue
+			}
+		default:
+			continue
+		}
+
 		b.Log.Debugf("%#v %#v", message.Raw.GetData(), message.Raw.EventType())
 
 		if b.skipMessage(message) {
@@ -128,6 +145,15 @@ func (b *Bmattermost) handleMatterClient(messages chan *config.Message) {
 		// handle mattermost post properties (override username and attachments)
 		b.handleProps(rmsg, message)
 
+		// Extract message priority from Post.Metadata if present.
+		if message.Post.Metadata != nil && message.Post.Metadata.Priority != nil &&
+			message.Post.Metadata.Priority.Priority != nil {
+			prio := *message.Post.Metadata.Priority.Priority
+			if prio != "" && prio != "standard" {
+				rmsg.Extra["priority"] = []interface{}{prio}
+			}
+		}
+
 		// create a text for bridges that don't support native editing
 		if message.Raw.EventType() == model.WebsocketEventPostEdited && !b.GetBool("EditDisable") {
 			rmsg.Text = message.Text + b.GetString("EditSuffix")
@@ -144,13 +170,25 @@ func (b *Bmattermost) handleMatterClient(messages chan *config.Message) {
 			}
 		}
 
+		// Intercept test command before relaying.
+		if b.isTestCommand(rmsg.Text) {
+			b.Log.Info("Test command received, starting test sequence")
+			go b.runTestSequence(channelName)
+			continue
+		}
+
 		// Use nickname instead of username if defined
 		if !b.GetBool("useusername") {
 			if nick := b.mc.GetNickName(rmsg.UserID); nick != "" {
 				rmsg.Username = nick
 			}
 		}
 
+		// Populate full display name (FirstName + LastName) for bridges that support it.
+		if dn := b.getDisplayName(rmsg.UserID); dn != "" {
+			rmsg.Extra["displayname"] = []interface{}{dn}
+		}
+
 		messages <- rmsg
 	}
 }
@@ -170,22 +208,58 @@ func (b *Bmattermost) handleMatterHook(messages chan *config.Message) {
 }
 
 func (b *Bmattermost) handleUploadFile(msg *config.Message) (string, error) {
-	var err error
-	var res, id string
 	channelID := b.getChannelID(msg.Channel)
-	for _, f := range msg.Extra["file"] {
+
+	// Upload all files first, then create a single post with all file IDs.
+	var fileIDs []string
+	var firstComment string
+	for i, f := range msg.Extra["file"] {
 		fi := f.(config.FileInfo)
-		id, err = b.mc.UploadFile(*fi.Data, channelID, fi.Name)
+		fileID, err := b.mc.UploadFile(*fi.Data, channelID, fi.Name)
 		if err != nil {
-			return "", err
+			b.Log.Errorf("upload file %s failed: %s", fi.Name, err)
+			continue
 		}
-		msg.Text = fi.Comment
-		if b.GetBool("PrefixMessagesWithNick") {
-			msg.Text = msg.Username + msg.Text
+		fileIDs = append(fileIDs, fileID)
+		if i == 0 {
+			firstComment = fi.Comment
 		}
-		res, err = b.mc.PostMessageWithFiles(channelID, msg.Text, msg.ParentID, []string{id})
 	}
-	return res, err
+
+	if len(fileIDs) == 0 {
+		return "", fmt.Errorf("no files uploaded successfully")
+	}
+
+	text := firstComment
+
+	// Build a single post with all files so they appear as one message
+	// with the bridged user's name and avatar via override_username.
+	post := &model.Post{
+		ChannelId: channelID,
+		Message:   text,
+		RootId:    msg.ParentID,
+		FileIds:   fileIDs,
+		Props: model.StringInterface{
+			"from_webhook":           "true",
+			"override_username":      strings.TrimSpace(msg.Username),
+			"matterbridge_" + b.uuid: true,
+		},
+	}
+	if msg.Avatar != "" {
+		post.Props["override_icon_url"] = msg.Avatar
+	}
+	if msg.Extra != nil {
+		if srcIDs, ok := msg.Extra["source_msgid"]; ok && len(srcIDs) > 0 {
+			if srcID, ok := srcIDs[0].(string); ok {
+				post.Props["matterbridge_srcid"] = srcID
+			}
+		}
+	}
+	created, _, err := b.mc.Client.CreatePost(context.TODO(), post)
+	if err != nil {
+		return "", err
+	}
+	return created.Id, nil
 }
 
 //nolint:forcetypeassert

bridge/mattermost/helpers.go

@@ -117,7 +117,11 @@ func (b *Bmattermost) sendWebhook(msg config.Message) (string, error) {
 		return "", nil
 	}
 
-	if b.GetBool("PrefixMessagesWithNick") {
+	// When the webhook sets override_username (msg.Username is non-empty),
+	// do NOT prefix the message with the nick — it would show up twice
+	// (once as the sender name, once in the message body).
+	// Only prefix when there's no username to use as override.
+	if b.GetBool("PrefixMessagesWithNick") && msg.Username == "" {
 		msg.Text = msg.Username + msg.Text
 	}
 
@@ -227,8 +231,11 @@ func (b *Bmattermost) skipMessage(message *matterclient.Message) bool {
 		}
 	}
 
-	// Ignore messages sent from a user logged in as the bot
-	if b.mc.User.Username == message.Username {
+	// Allow test messages from ourselves to be relayed (bypass echo prevention).
+	isTestMessage := message.Post.Props != nil && message.Post.Props["matterbridge_test"] != nil
+
+	// Ignore messages sent from a user logged in as the bot (unless it's a test message).
+	if !isTestMessage && b.mc.User.Username == message.Username {
 		b.Log.Debug("message from same user as bot, ignoring")
 		return true
 	}