feat: domain blocker plugin

internal/platform/slack/slack.go

@@ -167,6 +167,12 @@ func (s *SlackPlatform) SendMessage(msg *model.Message) error {
 		return errors.New("bot token not configured")
 	}
 
+	// Check for delete message action
+	if msg.Raw != nil && msg.Raw["action"] == "delete" {
+		// This is a request to delete a message
+		return s.deleteMessage(msg)
+	}
+
 	// Prepare payload
 	payload := map[string]interface{}{
 		"channel": msg.Chat,
@@ -212,6 +218,63 @@ func (s *SlackPlatform) SendMessage(msg *model.Message) error {
 	return nil
 }
 
+// DeleteMessage deletes a message on Slack
+func (s *SlackPlatform) DeleteMessage(channel string, messageID string) error {
+	// Prepare payload for chat.delete API
+	payload := map[string]interface{}{
+		"channel": channel,
+		"ts":      messageID, // In Slack, the ts (timestamp) is the message ID
+	}
+
+	// Convert payload to JSON
+	data, err := json.Marshal(payload)
+	if err != nil {
+		return err
+	}
+
+	// Send HTTP request to chat.delete endpoint
+	req, err := http.NewRequest("POST", "https://slack.com/api/chat.delete", strings.NewReader(string(data)))
+	if err != nil {
+		return err
+	}
+
+	req.Header.Set("Content-Type", "application/json")
+	req.Header.Set("Authorization", fmt.Sprintf("Bearer %s", s.config.BotOAuthAccessToken))
+
+	client := &http.Client{}
+	resp, err := client.Do(req)
+	if err != nil {
+		return err
+	}
+	defer func() {
+		if err := resp.Body.Close(); err != nil {
+			fmt.Printf("Error closing response body: %v\n", err)
+		}
+	}()
+
+	// Check response
+	if resp.StatusCode != http.StatusOK {
+		respBody, _ := io.ReadAll(resp.Body)
+		return fmt.Errorf("slack API error: %d - %s", resp.StatusCode, string(respBody))
+	}
+
+	return nil
+}
+
+// deleteMessage is a legacy method that uses the Raw message approach
+func (s *SlackPlatform) deleteMessage(msg *model.Message) error {
+	// Get message ID to delete
+	messageID, ok := msg.Raw["message_id"]
+	if !ok {
+		return fmt.Errorf("no message ID provided for deletion")
+	}
+	
+	// Convert to string if needed
+	messageIDStr := fmt.Sprintf("%v", messageID)
+	
+	return s.DeleteMessage(msg.Chat, messageIDStr)
+}
+
 // Helper function to parse int64
 func parseInt64(s string) (int64, error) {
 	var n int64

internal/platform/telegram/telegram.go

@@ -217,6 +217,13 @@ func (t *TelegramPlatform) ParseChannelFromMessage(body []byte) (map[string]any,
 
 // SendMessage sends a message to Telegram
 func (t *TelegramPlatform) SendMessage(msg *model.Message) error {
+	// Check for delete message action (legacy method)
+	if msg.Raw != nil && msg.Raw["action"] == "delete" {
+		// This is a request to delete a message using the legacy method
+		return t.deleteMessage(msg)
+	}
+
+	// Regular message sending
 	// Convert chat ID to int64
 	chatID, err := strconv.ParseInt(msg.Chat, 10, 64)
 	if err != nil {
@@ -276,3 +283,88 @@ func (t *TelegramPlatform) SendMessage(msg *model.Message) error {
 	t.log.Debug("Message sent successfully")
 	return nil
 }
+
+// DeleteMessage deletes a message on Telegram
+func (t *TelegramPlatform) DeleteMessage(channel string, messageID string) error {
+	// Convert chat ID to int64
+	chatID, err := strconv.ParseInt(channel, 10, 64)
+	if err != nil {
+		t.log.Error("Invalid chat ID for message deletion", "chat_id", channel, "error", err)
+		return err
+	}
+
+	// Convert message ID to integer
+	msgID, err := strconv.Atoi(messageID)
+	if err != nil {
+		t.log.Error("Invalid message ID for deletion", "message_id", messageID, "error", err)
+		return err
+	}
+
+	// Prepare payload for deleteMessage API
+	payload := map[string]interface{}{
+		"chat_id":    chatID,
+		"message_id": msgID,
+	}
+
+	t.log.Debug("Deleting message on Telegram", "chat_id", chatID, "message_id", msgID)
+
+	// Convert payload to JSON
+	data, err := json.Marshal(payload)
+	if err != nil {
+		t.log.Error("Failed to marshal delete message payload", "error", err)
+		return err
+	}
+
+	// Send HTTP request to deleteMessage endpoint
+	resp, err := http.Post(
+		t.apiURL+"/deleteMessage",
+		"application/json",
+		bytes.NewBuffer(data),
+	)
+	if err != nil {
+		t.log.Error("Failed to delete message", "error", err)
+		return err
+	}
+	defer func() {
+		if err := resp.Body.Close(); err != nil {
+			t.log.Error("Error closing response body", "error", err)
+		}
+	}()
+
+	// Check response
+	if resp.StatusCode != http.StatusOK {
+		bodyBytes, _ := io.ReadAll(resp.Body)
+		errMsg := string(bodyBytes)
+		t.log.Error("Telegram API error when deleting message", "status", resp.StatusCode, "response", errMsg)
+		return fmt.Errorf("telegram API error when deleting message: %d - %s", resp.StatusCode, errMsg)
+	}
+
+	t.log.Debug("Message deleted successfully")
+	return nil
+}
+
+// deleteMessage is a legacy method that uses the Raw message approach
+func (t *TelegramPlatform) deleteMessage(msg *model.Message) error {
+	// Get message ID to delete
+	messageIDInterface, ok := msg.Raw["message_id"]
+	if !ok {
+		t.log.Error("No message ID provided for deletion")
+		return fmt.Errorf("no message ID provided for deletion")
+	}
+
+	// Convert message ID to string
+	var messageIDStr string
+	switch v := messageIDInterface.(type) {
+	case string:
+		messageIDStr = v
+	case int:
+		messageIDStr = strconv.Itoa(v)
+	case float64:
+		messageIDStr = strconv.Itoa(int(v))
+	default:
+		t.log.Error("Invalid message ID type for deletion", "type", fmt.Sprintf("%T", messageIDInterface))
+		return fmt.Errorf("invalid message ID type for deletion")
+	}
+
+	return t.DeleteMessage(msg.Chat, messageIDStr)
+}