From e0ae0c2a0b5aba03c5f08bf52e96081479113c37 Mon Sep 17 00:00:00 2001
From: "Felipe M." <me@fmartingr.com>
Date: Mon, 21 Apr 2025 15:50:28 +0200
Subject: [PATCH 01/11] fix: missing ca-certs

---
 .goreleaser.yml         | 2 +-
 cmd/butterrobot/main.go | 2 ++
 go.mod                  | 1 +
 go.sum                  | 2 ++
 4 files changed, 6 insertions(+), 1 deletion(-)

diff --git a/.goreleaser.yml b/.goreleaser.yml
index c89e189..a3836e9 100644
--- a/.goreleaser.yml
+++ b/.goreleaser.yml
@@ -93,7 +93,7 @@ docker_manifests:
 
 nfpms:
   - maintainer: Felipe Martin <me@fmartingr.com>
-    description: SMTP server to forward messages to shoutrrr endpoints
+    description: A chatbot server with customizable commands and triggers
     homepage: https://git.nakama.town/fmartingr/butterrobot
     license: AGPL-3.0
     formats:
diff --git a/cmd/butterrobot/main.go b/cmd/butterrobot/main.go
index 2982a96..3bc56cb 100644
--- a/cmd/butterrobot/main.go
+++ b/cmd/butterrobot/main.go
@@ -8,6 +8,8 @@ import (
 
 	"git.nakama.town/fmartingr/butterrobot/internal/app"
 	"git.nakama.town/fmartingr/butterrobot/internal/config"
+
+	_ "golang.org/x/crypto/x509roots/fallback"
 )
 
 func main() {
diff --git a/go.mod b/go.mod
index 3f17f0d..cd1bee5 100644
--- a/go.mod
+++ b/go.mod
@@ -5,6 +5,7 @@ go 1.24
 require (
 	github.com/gorilla/sessions v1.4.0
 	golang.org/x/crypto v0.37.0
+	golang.org/x/crypto/x509roots/fallback v0.0.0-20250418111936-9c1aa6af88df
 	modernc.org/sqlite v1.37.0
 )
 
diff --git a/go.sum b/go.sum
index f331cb5..00c4a3c 100644
--- a/go.sum
+++ b/go.sum
@@ -18,6 +18,8 @@ github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec h1:W09IVJc94
 github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec/go.mod h1:qqbHyh8v60DhA7CoWK5oRCqLrMHRGoxYCSS9EjAz6Eo=
 golang.org/x/crypto v0.37.0 h1:kJNSjF/Xp7kU0iB2Z+9viTPMW4EqqsrywMXLJOOsXSE=
 golang.org/x/crypto v0.37.0/go.mod h1:vg+k43peMZ0pUMhYmVAWysMK35e6ioLh3wB8ZCAfbVc=
+golang.org/x/crypto/x509roots/fallback v0.0.0-20250418111936-9c1aa6af88df h1:SwgTucX8ajPE0La2ELpYOIs8jVMoCMpAvYB6mDqP9vk=
+golang.org/x/crypto/x509roots/fallback v0.0.0-20250418111936-9c1aa6af88df/go.mod h1:lxN5T34bK4Z/i6cMaU7frUU57VkDXFD4Kamfl/cp9oU=
 golang.org/x/exp v0.0.0-20250408133849-7e4ce0ab07d0 h1:R84qjqJb5nVJMxqWYb3np9L5ZsaDtB+a39EqjV0JSUM=
 golang.org/x/exp v0.0.0-20250408133849-7e4ce0ab07d0/go.mod h1:S9Xr4PYopiDyqSyp5NjCrhFrqg6A5zA2E/iPHPhqnS8=
 golang.org/x/mod v0.24.0 h1:ZfthKaKaT4NrhGVZHO1/WDTwGES4De8KtWO0SIbNJMU=

From c920eb94a035913bf4f5dc98fe6ee26ff0c3f66f Mon Sep 17 00:00:00 2001
From: "Felipe M." <me@fmartingr.com>
Date: Mon, 21 Apr 2025 18:03:07 +0200
Subject: [PATCH 02/11] feat: added twitter and instagram link expanders

---
 internal/app/app.go                 |  3 ++
 internal/plugin/social/instagram.go | 76 +++++++++++++++++++++++++++
 internal/plugin/social/twitter.go   | 79 +++++++++++++++++++++++++++++
 3 files changed, 158 insertions(+)
 create mode 100644 internal/plugin/social/instagram.go
 create mode 100644 internal/plugin/social/twitter.go

diff --git a/internal/app/app.go b/internal/app/app.go
index 8d4ffcd..2e15bf6 100644
--- a/internal/app/app.go
+++ b/internal/app/app.go
@@ -20,6 +20,7 @@ import (
 	"git.nakama.town/fmartingr/butterrobot/internal/plugin"
 	"git.nakama.town/fmartingr/butterrobot/internal/plugin/fun"
 	"git.nakama.town/fmartingr/butterrobot/internal/plugin/ping"
+	"git.nakama.town/fmartingr/butterrobot/internal/plugin/social"
 	"git.nakama.town/fmartingr/butterrobot/internal/queue"
 )
 
@@ -72,6 +73,8 @@ func (a *App) Run() error {
 	plugin.Register(fun.NewCoin())
 	plugin.Register(fun.NewDice())
 	plugin.Register(fun.NewLoquito())
+	plugin.Register(social.NewTwitterExpander())
+	plugin.Register(social.NewInstagramExpander())
 
 	// Initialize routes
 	a.initializeRoutes()
diff --git a/internal/plugin/social/instagram.go b/internal/plugin/social/instagram.go
new file mode 100644
index 0000000..a4f758a
--- /dev/null
+++ b/internal/plugin/social/instagram.go
@@ -0,0 +1,76 @@
+package social
+
+import (
+	"net/url"
+	"regexp"
+	"strings"
+
+	"git.nakama.town/fmartingr/butterrobot/internal/model"
+	"git.nakama.town/fmartingr/butterrobot/internal/plugin"
+)
+
+// InstagramExpander transforms instagram.com links to ddinstagram.com links
+type InstagramExpander struct {
+	plugin.BasePlugin
+}
+
+// New creates a new InstagramExpander instance
+func NewInstagramExpander() *InstagramExpander {
+	return &InstagramExpander{
+		BasePlugin: plugin.BasePlugin{
+			ID:   "social.instagram",
+			Name: "Instagram Link Expander",
+			Help: "Automatically converts instagram.com links to ddinstagram.com links and removes tracking parameters",
+		},
+	}
+}
+
+// OnMessage handles incoming messages
+func (p *InstagramExpander) OnMessage(msg *model.Message, config map[string]interface{}) []*model.Message {
+	// Skip empty messages
+	if strings.TrimSpace(msg.Text) == "" {
+		return nil
+	}
+
+	// Regex to match instagram.com links
+	// Match both http://instagram.com and https://instagram.com formats
+	// Also match www.instagram.com
+	instagramRegex := regexp.MustCompile(`https?://(www\.)?(instagram\.com)/[^\s]+`)
+
+	// Check if the message contains an Instagram link
+	if !instagramRegex.MatchString(msg.Text) {
+		return nil
+	}
+
+	// Replace instagram.com with ddinstagram.com in the message and clean query parameters
+	transformed := instagramRegex.ReplaceAllStringFunc(msg.Text, func(link string) string {
+		// Parse the URL
+		parsedURL, err := url.Parse(link)
+		if err != nil {
+			// If parsing fails, just do the simple replacement
+			link = strings.Replace(link, "instagram.com", "ddinstagram.com", 1)
+			return link
+		}
+
+		// Change the host
+		if strings.Contains(parsedURL.Host, "instagram.com") {
+			parsedURL.Host = strings.Replace(parsedURL.Host, "instagram.com", "ddinstagram.com", 1)
+		}
+
+		// Remove query parameters
+		parsedURL.RawQuery = ""
+
+		// Return the cleaned URL
+		return parsedURL.String()
+	})
+
+	// Create response message
+	response := &model.Message{
+		Text:    transformed,
+		Chat:    msg.Chat,
+		ReplyTo: msg.ID,
+		Channel: msg.Channel,
+	}
+
+	return []*model.Message{response}
+}
diff --git a/internal/plugin/social/twitter.go b/internal/plugin/social/twitter.go
new file mode 100644
index 0000000..837b6c9
--- /dev/null
+++ b/internal/plugin/social/twitter.go
@@ -0,0 +1,79 @@
+package social
+
+import (
+	"net/url"
+	"regexp"
+	"strings"
+
+	"git.nakama.town/fmartingr/butterrobot/internal/model"
+	"git.nakama.town/fmartingr/butterrobot/internal/plugin"
+)
+
+// TwitterExpander transforms twitter.com links to fxtwitter.com links
+type TwitterExpander struct {
+	plugin.BasePlugin
+}
+
+// New creates a new TwitterExpander instance
+func NewTwitterExpander() *TwitterExpander {
+	return &TwitterExpander{
+		BasePlugin: plugin.BasePlugin{
+			ID:   "social.twitter",
+			Name: "Twitter Link Expander",
+			Help: "Automatically converts twitter.com links to fxtwitter.com links and removes tracking parameters",
+		},
+	}
+}
+
+// OnMessage handles incoming messages
+func (p *TwitterExpander) OnMessage(msg *model.Message, config map[string]interface{}) []*model.Message {
+	// Skip empty messages
+	if strings.TrimSpace(msg.Text) == "" {
+		return nil
+	}
+
+	// Regex to match twitter.com links
+	// Match both http://twitter.com and https://twitter.com formats
+	// Also match www.twitter.com
+	twitterRegex := regexp.MustCompile(`https?://(www\.)?(twitter\.com|x\.com)/[^\s]+`)
+
+	// Check if the message contains a Twitter link
+	if !twitterRegex.MatchString(msg.Text) {
+		return nil
+	}
+
+	// Replace twitter.com with fxtwitter.com in the message and clean query parameters
+	transformed := twitterRegex.ReplaceAllStringFunc(msg.Text, func(link string) string {
+		// Parse the URL
+		parsedURL, err := url.Parse(link)
+		if err != nil {
+			// If parsing fails, just do the simple replacement
+			link = strings.Replace(link, "twitter.com", "fxtwitter.com", 1)
+			link = strings.Replace(link, "x.com", "fxtwitter.com", 1)
+			return link
+		}
+
+		// Change the host
+		if strings.Contains(parsedURL.Host, "twitter.com") {
+			parsedURL.Host = strings.Replace(parsedURL.Host, "twitter.com", "fxtwitter.com", 1)
+		} else if strings.Contains(parsedURL.Host, "x.com") {
+			parsedURL.Host = strings.Replace(parsedURL.Host, "x.com", "fxtwitter.com", 1)
+		}
+
+		// Remove query parameters
+		parsedURL.RawQuery = ""
+
+		// Return the cleaned URL
+		return parsedURL.String()
+	})
+
+	// Create response message
+	response := &model.Message{
+		Text:    transformed,
+		Chat:    msg.Chat,
+		ReplyTo: msg.ID,
+		Channel: msg.Channel,
+	}
+
+	return []*model.Message{response}
+}

From a0f12efd65c0d1999cbeaf39b47727a284c02f01 Mon Sep 17 00:00:00 2001
From: "Felipe M." <me@fmartingr.com>
Date: Mon, 21 Apr 2025 18:08:40 +0200
Subject: [PATCH 03/11] feat: show version in admin page

---
 internal/admin/admin.go             |  6 ++++-
 internal/admin/templates/_base.html | 13 +++++++++++
 internal/app/app.go                 | 36 ++++++++++++++++++-----------
 3 files changed, 41 insertions(+), 14 deletions(-)

diff --git a/internal/admin/admin.go b/internal/admin/admin.go
index 045d980..822495a 100644
--- a/internal/admin/admin.go
+++ b/internal/admin/admin.go
@@ -46,6 +46,7 @@ type TemplateData struct {
 	Channels      []*model.Channel
 	Channel       *model.Channel
 	ChannelPlugin *model.ChannelPlugin
+	Version       string
 }
 
 // Admin represents the admin interface
@@ -55,10 +56,11 @@ type Admin struct {
 	store        *sessions.CookieStore
 	templates    map[string]*template.Template
 	baseTemplate *template.Template
+	version      string
 }
 
 // New creates a new Admin instance
-func New(cfg *config.Config, database *db.Database) *Admin {
+func New(cfg *config.Config, database *db.Database, version string) *Admin {
 	// Create session store with appropriate options
 	store := sessions.NewCookieStore([]byte(cfg.SecretKey))
 	store.Options = &sessions.Options{
@@ -126,6 +128,7 @@ func New(cfg *config.Config, database *db.Database) *Admin {
 		store:        store,
 		templates:    templates,
 		baseTemplate: baseTemplate,
+		version:      version,
 	}
 }
 
@@ -264,6 +267,7 @@ func (a *Admin) render(w http.ResponseWriter, r *http.Request, templateName stri
 	data.LoggedIn = a.isLoggedIn(r)
 	data.Path = r.URL.Path
 	data.Flash = a.getFlashes(w, r)
+	data.Version = a.version
 
 	// Get template
 	tmpl, ok := a.templates[templateName]
diff --git a/internal/admin/templates/_base.html b/internal/admin/templates/_base.html
index 4a414e3..3ebdf85 100644
--- a/internal/admin/templates/_base.html
+++ b/internal/admin/templates/_base.html
@@ -117,6 +117,19 @@
             </div>
         </div>
 
+        <footer class="footer footer-transparent d-print-none">
+            <div class="container-xl">
+                <div class="row text-center align-items-center flex-row-reverse">
+                    <div class="col-12 col-lg-auto mt-3 mt-lg-0">
+                        <ul class="list-inline list-inline-dots mb-0">
+                            <li class="list-inline-item">
+                                ButterRobot {{if .Version}}v{{.Version}}{{else}}(development){{end}}
+                            </li>
+                        </ul>
+                    </div>
+                </div>
+            </div>
+        </footer>
     </div>
 
     <script src="https://unpkg.com/@tabler/core@latest/dist/js/tabler.min.js"></script>
diff --git a/internal/app/app.go b/internal/app/app.go
index 2e15bf6..5126672 100644
--- a/internal/app/app.go
+++ b/internal/app/app.go
@@ -9,6 +9,7 @@ import (
 	"net/http"
 	"os"
 	"os/signal"
+	"runtime/debug"
 	"strings"
 	"syscall"
 	"time"
@@ -26,12 +27,13 @@ import (
 
 // App represents the application
 type App struct {
-	config *config.Config
-	logger *slog.Logger
-	db     *db.Database
-	router *http.ServeMux
-	queue  *queue.Queue
-	admin  *admin.Admin
+	config  *config.Config
+	logger  *slog.Logger
+	db      *db.Database
+	router  *http.ServeMux
+	queue   *queue.Queue
+	admin   *admin.Admin
+	version string
 }
 
 // New creates a new App instance
@@ -48,16 +50,24 @@ func New(cfg *config.Config, logger *slog.Logger) (*App, error) {
 	// Initialize message queue
 	messageQueue := queue.New(logger)
 
+	// Get version information
+	version := ""
+	info, ok := debug.ReadBuildInfo()
+	if ok {
+		version = info.Main.Version
+	}
+
 	// Initialize admin interface
-	adminInterface := admin.New(cfg, database)
+	adminInterface := admin.New(cfg, database, version)
 
 	return &App{
-		config: cfg,
-		logger: logger,
-		db:     database,
-		router: router,
-		queue:  messageQueue,
-		admin:  adminInterface,
+		config:  cfg,
+		logger:  logger,
+		db:      database,
+		router:  router,
+		queue:   messageQueue,
+		admin:   adminInterface,
+		version: version,
 	}, nil
 }
 

From 21e4c434fd8ce549ee128ab2b1d1795a4a6007ef Mon Sep 17 00:00:00 2001
From: "Felipe M." <me@fmartingr.com>
Date: Mon, 21 Apr 2025 18:10:30 +0200
Subject: [PATCH 04/11] docs: updated plugin docs

---
 docs/creating-a-plugin.md | 105 +++++++++++++++++++++++++++++++++++++-
 docs/plugins.md           |   5 ++
 2 files changed, 108 insertions(+), 2 deletions(-)

diff --git a/docs/creating-a-plugin.md b/docs/creating-a-plugin.md
index 945d03c..469491a 100644
--- a/docs/creating-a-plugin.md
+++ b/docs/creating-a-plugin.md
@@ -1,6 +1,18 @@
 # Creating a Plugin
 
-## Example
+## Plugin Categories
+
+ButterRobot organizes plugins into different categories:
+
+- **Development**: Utility plugins like `ping`
+- **Fun**: Entertainment plugins like dice rolling, coin flipping
+- **Social**: Social media related plugins like URL transformers/expanders
+
+When creating a new plugin, consider which category it fits into and place it in the appropriate directory.
+
+## Plugin Examples
+
+### Basic Example: Marco Polo
 
 This simple "Marco Polo" plugin will answer _Polo_ to the user that says _Marco_:
 
@@ -47,6 +59,92 @@ func (p *MarcoPlugin) OnMessage(msg *model.Message, config map[string]interface{
 }
 ```
 
+### Advanced Example: URL Transformer
+
+This more complex plugin transforms URLs, useful for improving media embedding in chat platforms:
+
+```go
+package social
+
+import (
+	"net/url"
+	"regexp"
+	"strings"
+
+	"git.nakama.town/fmartingr/butterrobot/internal/model"
+	"git.nakama.town/fmartingr/butterrobot/internal/plugin"
+)
+
+// TwitterExpander transforms twitter.com links to fxtwitter.com links
+type TwitterExpander struct {
+	plugin.BasePlugin
+}
+
+// New creates a new TwitterExpander instance
+func NewTwitter() *TwitterExpander {
+	return &TwitterExpander{
+		BasePlugin: plugin.BasePlugin{
+			ID:   "social.twitter",
+			Name: "Twitter Link Expander",
+			Help: "Automatically converts twitter.com links to fxtwitter.com links and removes tracking parameters",
+		},
+	}
+}
+
+// OnMessage handles incoming messages
+func (p *TwitterExpander) OnMessage(msg *model.Message, config map[string]interface{}) []*model.Message {
+	// Skip empty messages
+	if strings.TrimSpace(msg.Text) == "" {
+		return nil
+	}
+
+	// Regex to match twitter.com links
+	twitterRegex := regexp.MustCompile(`https?://(www\.)?(twitter\.com|x\.com)/[^\s]+`)
+
+	// Check if the message contains a Twitter link
+	if !twitterRegex.MatchString(msg.Text) {
+		return nil
+	}
+
+	// Transform the URL
+	transformed := twitterRegex.ReplaceAllStringFunc(msg.Text, func(link string) string {
+		// Parse the URL
+		parsedURL, err := url.Parse(link)
+		if err != nil {
+			// If parsing fails, just do the simple replacement
+			link = strings.Replace(link, "twitter.com", "fxtwitter.com", 1)
+			link = strings.Replace(link, "x.com", "fxtwitter.com", 1)
+			return link
+		}
+		
+		// Change the host
+		if strings.Contains(parsedURL.Host, "twitter.com") {
+			parsedURL.Host = strings.Replace(parsedURL.Host, "twitter.com", "fxtwitter.com", 1)
+		} else if strings.Contains(parsedURL.Host, "x.com") {
+			parsedURL.Host = strings.Replace(parsedURL.Host, "x.com", "fxtwitter.com", 1)
+		}
+		
+		// Remove query parameters
+		parsedURL.RawQuery = ""
+		
+		// Return the cleaned URL
+		return parsedURL.String()
+	})
+
+	// Create response message
+	response := &model.Message{
+		Text:    transformed,
+		Chat:    msg.Chat,
+		ReplyTo: msg.ID,
+		Channel: msg.Channel,
+	}
+
+	return []*model.Message{response}
+}
+```
+
+## Registering Plugins
+
 To use the plugin, register it in your application:
 
 ```go
@@ -55,7 +153,10 @@ func (a *App) Run() error {
     // ...
 
     // Register plugins
-    plugin.Register(myplugin.New())
+    plugin.Register(ping.New())                 // Development plugin
+    plugin.Register(fun.NewCoin())              // Fun plugin  
+    plugin.Register(social.NewTwitter())        // Social media plugin
+    plugin.Register(myplugin.New())             // Your custom plugin
 
     // ...
 }
diff --git a/docs/plugins.md b/docs/plugins.md
index 11e3d16..2988f80 100644
--- a/docs/plugins.md
+++ b/docs/plugins.md
@@ -9,3 +9,8 @@
 - Lo quito: What happens when you say _"lo quito"_...? (Spanish pun)
 - Dice: Put `!dice` and wathever roll you want to perform.
 - Coin: Flip a coin and get heads or tails.
+
+### Social Media
+
+- Twitter Link Expander: Automatically converts twitter.com and x.com links to fxtwitter.com links and removes tracking parameters. This allows for better media embedding in chat platforms.
+- Instagram Link Expander: Automatically converts instagram.com links to ddinstagram.com links and removes tracking parameters. This allows for better media embedding in chat platforms.

From 72c6dd69823b680e1201b990e60215ce9205fd33 Mon Sep 17 00:00:00 2001
From: "Felipe M." <me@fmartingr.com>
Date: Tue, 22 Apr 2025 11:29:39 +0200
Subject: [PATCH 05/11] feat: remindme plugin

---
 docs/plugins.md                           |   4 +
 internal/admin/admin.go                   |   8 +-
 internal/app/app.go                       |  79 ++++++++++
 internal/db/db.go                         | 127 ++++++++++++++-
 internal/migration/migration.go           |   2 +-
 internal/migration/migrations.go          |  32 +++-
 internal/model/message.go                 |  53 ++++---
 internal/model/plugin.go                  |  10 +-
 internal/platform/telegram/telegram.go    |  10 +-
 internal/plugin/reminder/reminder.go      | 178 ++++++++++++++++++++++
 internal/plugin/reminder/reminder_test.go | 164 ++++++++++++++++++++
 internal/queue/queue.go                   |  76 ++++++++-
 12 files changed, 695 insertions(+), 48 deletions(-)
 create mode 100644 internal/plugin/reminder/reminder.go
 create mode 100644 internal/plugin/reminder/reminder_test.go

diff --git a/docs/plugins.md b/docs/plugins.md
index 2988f80..84578e5 100644
--- a/docs/plugins.md
+++ b/docs/plugins.md
@@ -10,6 +10,10 @@
 - Dice: Put `!dice` and wathever roll you want to perform.
 - Coin: Flip a coin and get heads or tails.
 
+### Utility
+
+- Remind Me: Reply to a message with `!remindme <duration>` to set a reminder. Supported duration units: y (years), mo (months), d (days), h (hours), m (minutes), s (seconds). Examples: `!remindme 1y` for 1 year, `!remindme 3mo` for 3 months, `!remindme 2d` for 2 days, `!remindme 3h` for 3 hours. The bot will mention you with a reminder after the specified time.
+
 ### Social Media
 
 - Twitter Link Expander: Automatically converts twitter.com and x.com links to fxtwitter.com links and removes tracking parameters. This allows for better media embedding in chat platforms.
diff --git a/internal/admin/admin.go b/internal/admin/admin.go
index 822495a..c2a78ca 100644
--- a/internal/admin/admin.go
+++ b/internal/admin/admin.go
@@ -106,19 +106,19 @@ func New(cfg *config.Config, database *db.Database, version string) *Admin {
 		if err != nil {
 			panic(err)
 		}
-		
+
 		// Create a clone of the base template
 		t, err := baseTemplate.Clone()
 		if err != nil {
 			panic(err)
 		}
-		
+
 		// Parse the template content
 		t, err = t.Parse(string(content))
 		if err != nil {
 			panic(err)
 		}
-		
+
 		templates[tf] = t
 	}
 
@@ -362,7 +362,7 @@ func (a *Admin) handleLogout(w http.ResponseWriter, r *http.Request) {
 		http.Redirect(w, r, "/admin/login", http.StatusSeeOther)
 		return
 	}
-	
+
 	session.Values = make(map[interface{}]interface{})
 	session.Options.MaxAge = -1 // Delete session
 	err = session.Save(r, w)
diff --git a/internal/app/app.go b/internal/app/app.go
index 5126672..1d878ab 100644
--- a/internal/app/app.go
+++ b/internal/app/app.go
@@ -17,10 +17,12 @@ import (
 	"git.nakama.town/fmartingr/butterrobot/internal/admin"
 	"git.nakama.town/fmartingr/butterrobot/internal/config"
 	"git.nakama.town/fmartingr/butterrobot/internal/db"
+	"git.nakama.town/fmartingr/butterrobot/internal/model"
 	"git.nakama.town/fmartingr/butterrobot/internal/platform"
 	"git.nakama.town/fmartingr/butterrobot/internal/plugin"
 	"git.nakama.town/fmartingr/butterrobot/internal/plugin/fun"
 	"git.nakama.town/fmartingr/butterrobot/internal/plugin/ping"
+	"git.nakama.town/fmartingr/butterrobot/internal/plugin/reminder"
 	"git.nakama.town/fmartingr/butterrobot/internal/plugin/social"
 	"git.nakama.town/fmartingr/butterrobot/internal/queue"
 )
@@ -86,12 +88,19 @@ func (a *App) Run() error {
 	plugin.Register(social.NewTwitterExpander())
 	plugin.Register(social.NewInstagramExpander())
 
+	// Register reminder plugin
+	reminderPlugin := reminder.New(a.db)
+	plugin.Register(reminderPlugin)
+
 	// Initialize routes
 	a.initializeRoutes()
 
 	// Start message queue worker
 	a.queue.Start(a.handleMessage)
 
+	// Start reminder scheduler
+	a.queue.StartReminderScheduler(a.handleReminder)
+
 	// Create server
 	addr := fmt.Sprintf(":%s", a.config.Port)
 	srv := &http.Server{
@@ -304,3 +313,73 @@ func (a *App) handleMessage(item queue.Item) {
 		}
 	}
 }
+
+// handleReminder handles reminder processing
+func (a *App) handleReminder(reminder *model.Reminder) {
+	// When called with nil, it means we should check for pending reminders
+	if reminder == nil {
+		// Get pending reminders
+		reminders, err := a.db.GetPendingReminders()
+		if err != nil {
+			a.logger.Error("Error getting pending reminders", "error", err)
+			return
+		}
+
+		// Process each reminder
+		for _, r := range reminders {
+			a.processReminder(r)
+		}
+		return
+	}
+
+	// Otherwise, process the specific reminder
+	a.processReminder(reminder)
+}
+
+// processReminder processes an individual reminder
+func (a *App) processReminder(reminder *model.Reminder) {
+	a.logger.Info("Processing reminder",
+		"id", reminder.ID,
+		"platform", reminder.Platform,
+		"channel", reminder.ChannelID,
+		"trigger_at", reminder.TriggerAt,
+	)
+
+	// Get the platform handler
+	p, err := platform.Get(reminder.Platform)
+	if err != nil {
+		a.logger.Error("Error getting platform for reminder", "error", err, "platform", reminder.Platform)
+		return
+	}
+
+	// Get the channel
+	channel, err := a.db.GetChannelByPlatform(reminder.Platform, reminder.ChannelID)
+	if err != nil {
+		a.logger.Error("Error getting channel for reminder", "error", err)
+		return
+	}
+
+	// Create the reminder message
+	reminderText := fmt.Sprintf("@%s reminding you of this", reminder.Username)
+
+	message := &model.Message{
+		Text:    reminderText,
+		Chat:    reminder.ChannelID,
+		Channel: channel,
+		Author:  "bot",
+		FromBot: true,
+		Date:    time.Now(),
+		ReplyTo: reminder.ReplyToID, // Reply to the original message
+	}
+
+	// Send the reminder message
+	if err := p.SendMessage(message); err != nil {
+		a.logger.Error("Error sending reminder", "error", err)
+		return
+	}
+
+	// Mark the reminder as processed
+	if err := a.db.MarkReminderAsProcessed(reminder.ID); err != nil {
+		a.logger.Error("Error marking reminder as processed", "error", err)
+	}
+}
diff --git a/internal/db/db.go b/internal/db/db.go
index 8cdce4a..b71b543 100644
--- a/internal/db/db.go
+++ b/internal/db/db.go
@@ -5,6 +5,7 @@ import (
 	"encoding/json"
 	"errors"
 	"fmt"
+	"time"
 
 	"golang.org/x/crypto/bcrypt"
 	_ "modernc.org/sqlite"
@@ -591,6 +592,120 @@ func (d *Database) UpdateUserPassword(userID int64, newPassword string) error {
 	return err
 }
 
+// CreateReminder creates a new reminder
+func (d *Database) CreateReminder(platform, channelID, messageID, replyToID, userID, username, content string, triggerAt time.Time) (*model.Reminder, error) {
+	query := `
+		INSERT INTO reminders (
+			platform, channel_id, message_id, reply_to_id, 
+			user_id, username, created_at, trigger_at, 
+			content, processed
+		) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, 0)
+	`
+
+	createdAt := time.Now()
+	result, err := d.db.Exec(
+		query,
+		platform, channelID, messageID, replyToID,
+		userID, username, createdAt, triggerAt,
+		content,
+	)
+	if err != nil {
+		return nil, err
+	}
+
+	id, err := result.LastInsertId()
+	if err != nil {
+		return nil, err
+	}
+
+	return &model.Reminder{
+		ID:        id,
+		Platform:  platform,
+		ChannelID: channelID,
+		MessageID: messageID,
+		ReplyToID: replyToID,
+		UserID:    userID,
+		Username:  username,
+		CreatedAt: createdAt,
+		TriggerAt: triggerAt,
+		Content:   content,
+		Processed: false,
+	}, nil
+}
+
+// GetPendingReminders gets all pending reminders that need to be processed
+func (d *Database) GetPendingReminders() ([]*model.Reminder, error) {
+	query := `
+		SELECT id, platform, channel_id, message_id, reply_to_id, 
+			   user_id, username, created_at, trigger_at, content, processed
+		FROM reminders
+		WHERE processed = 0 AND trigger_at <= ?
+	`
+
+	rows, err := d.db.Query(query, time.Now())
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+
+	var reminders []*model.Reminder
+
+	for rows.Next() {
+		var (
+			id                                        int64
+			platform, channelID, messageID, replyToID string
+			userID, username, content                 string
+			createdAt, triggerAt                      time.Time
+			processed                                 bool
+		)
+
+		if err := rows.Scan(
+			&id, &platform, &channelID, &messageID, &replyToID,
+			&userID, &username, &createdAt, &triggerAt, &content, &processed,
+		); err != nil {
+			return nil, err
+		}
+
+		reminder := &model.Reminder{
+			ID:        id,
+			Platform:  platform,
+			ChannelID: channelID,
+			MessageID: messageID,
+			ReplyToID: replyToID,
+			UserID:    userID,
+			Username:  username,
+			CreatedAt: createdAt,
+			TriggerAt: triggerAt,
+			Content:   content,
+			Processed: processed,
+		}
+
+		reminders = append(reminders, reminder)
+	}
+
+	if err := rows.Err(); err != nil {
+		return nil, err
+	}
+
+	if len(reminders) == 0 {
+		return make([]*model.Reminder, 0), nil
+	}
+
+	return reminders, nil
+}
+
+// MarkReminderAsProcessed marks a reminder as processed
+func (d *Database) MarkReminderAsProcessed(id int64) error {
+	query := `
+		UPDATE reminders
+		SET processed = 1
+		WHERE id = ?
+	`
+
+	_, err := d.db.Exec(query, id)
+	return err
+}
+
 // Helper function to hash password
 func hashPassword(password string) (string, error) {
 	// Use bcrypt for secure password hashing
@@ -609,25 +724,25 @@ func initDatabase(db *sql.DB) error {
 	if err := migration.EnsureMigrationTable(db); err != nil {
 		return fmt.Errorf("failed to create migration table: %w", err)
 	}
-	
+
 	// Get applied migrations
 	applied, err := migration.GetAppliedMigrations(db)
 	if err != nil {
 		return fmt.Errorf("failed to get applied migrations: %w", err)
 	}
-	
+
 	// Get all migration versions
 	allMigrations := make([]int, 0, len(migration.Migrations))
 	for version := range migration.Migrations {
 		allMigrations = append(allMigrations, version)
 	}
-	
+
 	// Create a map of applied migrations for quick lookup
 	appliedMap := make(map[int]bool)
 	for _, version := range applied {
 		appliedMap[version] = true
 	}
-	
+
 	// Count pending migrations
 	pendingCount := 0
 	for _, version := range allMigrations {
@@ -635,7 +750,7 @@ func initDatabase(db *sql.DB) error {
 			pendingCount++
 		}
 	}
-	
+
 	// Run migrations if needed
 	if pendingCount > 0 {
 		fmt.Printf("Running %d pending database migrations...\n", pendingCount)
@@ -646,6 +761,6 @@ func initDatabase(db *sql.DB) error {
 	} else {
 		fmt.Println("Database schema is up to date.")
 	}
-	
+
 	return nil
 }
diff --git a/internal/migration/migration.go b/internal/migration/migration.go
index 44096f3..dec4ff5 100644
--- a/internal/migration/migration.go
+++ b/internal/migration/migration.go
@@ -208,4 +208,4 @@ func MigrateDown(db *sql.DB, targetVersion int) error {
 	}
 
 	return nil
-}
\ No newline at end of file
+}
diff --git a/internal/migration/migrations.go b/internal/migration/migrations.go
index 2852113..8db229b 100644
--- a/internal/migration/migrations.go
+++ b/internal/migration/migrations.go
@@ -8,6 +8,7 @@ import (
 func init() {
 	// Register migrations
 	Register(1, "Initial schema with bcrypt passwords", migrateInitialSchemaUp, migrateInitialSchemaDown)
+	Register(2, "Add reminders table", migrateRemindersUp, migrateRemindersDown)
 }
 
 // Initial schema creation with bcrypt passwords - version 1
@@ -60,14 +61,14 @@ func migrateInitialSchemaUp(db *sql.DB) error {
 	if err != nil {
 		return err
 	}
-	
+
 	// Check if users table is empty before inserting
 	var count int
 	err = db.QueryRow("SELECT COUNT(*) FROM users").Scan(&count)
 	if err != nil {
 		return err
 	}
-	
+
 	if count == 0 {
 		_, err = db.Exec(
 			"INSERT INTO users (username, password) VALUES (?, ?)",
@@ -99,4 +100,29 @@ func migrateInitialSchemaDown(db *sql.DB) error {
 	}
 
 	return nil
-}
\ No newline at end of file
+}
+
+// Add reminders table - version 2
+func migrateRemindersUp(db *sql.DB) error {
+	_, err := db.Exec(`
+		CREATE TABLE IF NOT EXISTS reminders (
+			id INTEGER PRIMARY KEY AUTOINCREMENT,
+			platform TEXT NOT NULL,
+			channel_id TEXT NOT NULL,
+			message_id TEXT NOT NULL,
+			reply_to_id TEXT NOT NULL,
+			user_id TEXT NOT NULL,
+			username TEXT NOT NULL,
+			created_at TIMESTAMP NOT NULL,
+			trigger_at TIMESTAMP NOT NULL,
+			content TEXT NOT NULL,
+			processed BOOLEAN NOT NULL DEFAULT 0
+		)
+	`)
+	return err
+}
+
+func migrateRemindersDown(db *sql.DB) error {
+	_, err := db.Exec(`DROP TABLE IF EXISTS reminders`)
+	return err
+}
diff --git a/internal/model/message.go b/internal/model/message.go
index fe8c5e4..e6f86f6 100644
--- a/internal/model/message.go
+++ b/internal/model/message.go
@@ -6,25 +6,25 @@ import (
 
 // Message represents a chat message
 type Message struct {
-	Text     string
-	Chat     string
-	Channel  *Channel
-	Author   string
-	FromBot  bool
-	Date     time.Time
-	ID       string
-	ReplyTo  string
-	Raw      map[string]interface{}
+	Text    string
+	Chat    string
+	Channel *Channel
+	Author  string
+	FromBot bool
+	Date    time.Time
+	ID      string
+	ReplyTo string
+	Raw     map[string]interface{}
 }
 
 // Channel represents a chat channel
 type Channel struct {
-	ID               int64
-	Platform         string
+	ID                int64
+	Platform          string
 	PlatformChannelID string
-	ChannelRaw       map[string]interface{}
-	Enabled          bool
-	Plugins          map[string]*ChannelPlugin
+	ChannelRaw        map[string]interface{}
+	Enabled           bool
+	Plugins           map[string]*ChannelPlugin
 }
 
 // HasEnabledPlugin checks if a plugin is enabled for this channel
@@ -40,18 +40,18 @@ func (c *Channel) HasEnabledPlugin(pluginID string) bool {
 func (c *Channel) ChannelName() string {
 	// In a real implementation, this would use the platform-specific
 	// ParseChannelNameFromRaw function
-	
+
 	// For simplicity, we'll just use the PlatformChannelID if we can't extract a name
 	// Check if ChannelRaw has a name field
 	if c.ChannelRaw == nil {
 		return c.PlatformChannelID
 	}
-	
+
 	// Check common name fields in ChannelRaw
 	if name, ok := c.ChannelRaw["name"].(string); ok && name != "" {
 		return name
 	}
-	
+
 	// Check for nested objects like "chat" (used by Telegram)
 	if chat, ok := c.ChannelRaw["chat"].(map[string]interface{}); ok {
 		// Try different fields in order of preference
@@ -65,7 +65,7 @@ func (c *Channel) ChannelName() string {
 			return firstName
 		}
 	}
-	
+
 	return c.PlatformChannelID
 }
 
@@ -83,4 +83,19 @@ type User struct {
 	ID       int64
 	Username string
 	Password string
-}
\ No newline at end of file
+}
+
+// Reminder represents a scheduled reminder
+type Reminder struct {
+	ID        int64
+	Platform  string
+	ChannelID string
+	MessageID string
+	ReplyToID string
+	UserID    string
+	Username  string
+	CreatedAt time.Time
+	TriggerAt time.Time
+	Content   string
+	Processed bool
+}
diff --git a/internal/model/plugin.go b/internal/model/plugin.go
index ffc3c2f..9f2b34a 100644
--- a/internal/model/plugin.go
+++ b/internal/model/plugin.go
@@ -13,16 +13,16 @@ var (
 type Plugin interface {
 	// GetID returns the plugin ID
 	GetID() string
-	
+
 	// GetName returns the plugin name
 	GetName() string
-	
+
 	// GetHelp returns the plugin help text
 	GetHelp() string
-	
+
 	// RequiresConfig indicates if the plugin requires configuration
 	RequiresConfig() bool
-	
+
 	// OnMessage processes an incoming message and returns response messages
 	OnMessage(msg *Message, config map[string]interface{}) []*Message
-}
\ No newline at end of file
+}
diff --git a/internal/platform/telegram/telegram.go b/internal/platform/telegram/telegram.go
index a9ff2db..6c9a2b3 100644
--- a/internal/platform/telegram/telegram.go
+++ b/internal/platform/telegram/telegram.go
@@ -103,8 +103,11 @@ func (t *TelegramPlatform) ParseIncomingMessage(r *http.Request) (*model.Message
 				Title    string `json:"title,omitempty"`
 				Username string `json:"username,omitempty"`
 			} `json:"chat"`
-			Date int    `json:"date"`
-			Text string `json:"text"`
+			Date           int    `json:"date"`
+			Text           string `json:"text"`
+			ReplyToMessage struct {
+				MessageID int `json:"message_id"`
+			} `json:"reply_to_message"`
 		} `json:"message"`
 	}
 
@@ -128,6 +131,7 @@ func (t *TelegramPlatform) ParseIncomingMessage(r *http.Request) (*model.Message
 		FromBot: update.Message.From.IsBot,
 		Date:    time.Unix(int64(update.Message.Date), 0),
 		ID:      strconv.Itoa(update.Message.MessageID),
+		ReplyTo: strconv.Itoa(update.Message.ReplyToMessage.MessageID),
 		Raw:     raw,
 	}
 
@@ -259,4 +263,4 @@ func (t *TelegramPlatform) SendMessage(msg *model.Message) error {
 
 	t.log.Debug("Message sent successfully")
 	return nil
-}
\ No newline at end of file
+}
diff --git a/internal/plugin/reminder/reminder.go b/internal/plugin/reminder/reminder.go
new file mode 100644
index 0000000..6d7c1aa
--- /dev/null
+++ b/internal/plugin/reminder/reminder.go
@@ -0,0 +1,178 @@
+package reminder
+
+import (
+	"fmt"
+	"regexp"
+	"strconv"
+	"strings"
+	"time"
+
+	"git.nakama.town/fmartingr/butterrobot/internal/model"
+	"git.nakama.town/fmartingr/butterrobot/internal/plugin"
+)
+
+// Duration regex patterns to match reminders
+var (
+	remindMePattern = regexp.MustCompile(`(?i)^!remindme\s(\d+)(y|mo|d|h|m|s)$`)
+)
+
+// ReminderCreator is an interface for creating reminders
+type ReminderCreator interface {
+	CreateReminder(platform, channelID, messageID, replyToID, userID, username, content string, triggerAt time.Time) (*model.Reminder, error)
+}
+
+// Reminder is a plugin that sets reminders for messages
+type Reminder struct {
+	plugin.BasePlugin
+	creator ReminderCreator
+}
+
+// New creates a new Reminder plugin
+func New(creator ReminderCreator) *Reminder {
+	return &Reminder{
+		BasePlugin: plugin.BasePlugin{
+			ID:             "reminder.remindme",
+			Name:           "Remind Me",
+			Help:           "Reply to a message with `!remindme <duration>` to set a reminder (e.g., `!remindme 2d` for 2 days, `!remindme 1y` for 1 year).",
+			ConfigRequired: false,
+		},
+		creator: creator,
+	}
+}
+
+// OnMessage processes incoming messages
+func (r *Reminder) OnMessage(msg *model.Message, config map[string]interface{}) []*model.Message {
+	// Only process replies to messages
+	if msg.ReplyTo == "" {
+		return []*model.Message{
+			{
+				Text:    "Please reply to a message with `!remindme <duration>` to set a reminder.",
+				Chat:    msg.Chat,
+				Channel: msg.Channel,
+				ReplyTo: msg.ID,
+			},
+		}
+	}
+
+	// Check if the message is a reminder command
+	match := remindMePattern.FindStringSubmatch(msg.Text)
+	if match == nil {
+		return nil
+	}
+
+	// Parse the duration
+	amount, err := strconv.Atoi(match[1])
+	if err != nil {
+		return []*model.Message{
+			{
+				Text:    "Invalid duration format. Please use a number followed by y (years), mo (months), d (days), h (hours), m (minutes), or s (seconds).",
+				Chat:    msg.Chat,
+				Channel: msg.Channel,
+				Author:  "bot",
+				FromBot: true,
+				Date:    time.Now(),
+				ReplyTo: msg.ID,
+			},
+		}
+	}
+
+	// Calculate the trigger time
+	var duration time.Duration
+	unit := match[2]
+	switch strings.ToLower(unit) {
+	case "y":
+		duration = time.Duration(amount) * 365 * 24 * time.Hour
+	case "mo":
+		duration = time.Duration(amount) * 30 * 24 * time.Hour
+	case "d":
+		duration = time.Duration(amount) * 24 * time.Hour
+	case "h":
+		duration = time.Duration(amount) * time.Hour
+	case "m":
+		duration = time.Duration(amount) * time.Minute
+	case "s":
+		duration = time.Duration(amount) * time.Second
+	default:
+		return []*model.Message{
+			{
+				Text:    "Invalid duration unit. Please use y (years), mo (months), d (days), h (hours), m (minutes), or s (seconds).",
+				Chat:    msg.Chat,
+				Channel: msg.Channel,
+				Author:  "bot",
+				FromBot: true,
+				Date:    time.Now(),
+				ReplyTo: msg.ID,
+			},
+		}
+	}
+
+	triggerAt := time.Now().Add(duration)
+
+	// Determine the username for the reminder
+	username := msg.Author
+	if username == "" {
+		// Try to extract username from message raw data
+		if authorData, ok := msg.Raw["author"].(map[string]interface{}); ok {
+			if name, ok := authorData["username"].(string); ok {
+				username = name
+			} else if name, ok := authorData["name"].(string); ok {
+				username = name
+			}
+		}
+	}
+
+	// Create the reminder
+	_, err = r.creator.CreateReminder(
+		msg.Channel.Platform,
+		msg.Chat,
+		msg.ID,
+		msg.ReplyTo,
+		msg.Author,
+		username,
+		"", // No additional content for now
+		triggerAt,
+	)
+
+	if err != nil {
+		return []*model.Message{
+			{
+				Text:    fmt.Sprintf("Failed to create reminder: %v", err),
+				Chat:    msg.Chat,
+				Channel: msg.Channel,
+				Author:  "bot",
+				FromBot: true,
+				Date:    time.Now(),
+				ReplyTo: msg.ID,
+			},
+		}
+	}
+
+	// Format the acknowledgment message
+	var confirmText string
+	switch strings.ToLower(unit) {
+	case "y":
+		confirmText = fmt.Sprintf("I'll remind you about this message in %d year(s) on %s", amount, triggerAt.Format("Mon, Jan 2, 2006 at 15:04"))
+	case "mo":
+		confirmText = fmt.Sprintf("I'll remind you about this message in %d month(s) on %s", amount, triggerAt.Format("Mon, Jan 2 at 15:04"))
+	case "d":
+		confirmText = fmt.Sprintf("I'll remind you about this message in %d day(s) on %s", amount, triggerAt.Format("Mon, Jan 2 at 15:04"))
+	case "h":
+		confirmText = fmt.Sprintf("I'll remind you about this message in %d hour(s) at %s", amount, triggerAt.Format("15:04"))
+	case "m":
+		confirmText = fmt.Sprintf("I'll remind you about this message in %d minute(s) at %s", amount, triggerAt.Format("15:04"))
+	case "s":
+		confirmText = fmt.Sprintf("I'll remind you about this message in %d second(s)", amount)
+	}
+
+	return []*model.Message{
+		{
+			Text:    confirmText,
+			Chat:    msg.Chat,
+			Channel: msg.Channel,
+			Author:  "bot",
+			FromBot: true,
+			Date:    time.Now(),
+			ReplyTo: msg.ID,
+		},
+	}
+}
diff --git a/internal/plugin/reminder/reminder_test.go b/internal/plugin/reminder/reminder_test.go
new file mode 100644
index 0000000..b76fd2f
--- /dev/null
+++ b/internal/plugin/reminder/reminder_test.go
@@ -0,0 +1,164 @@
+package reminder
+
+import (
+	"testing"
+	"time"
+
+	"git.nakama.town/fmartingr/butterrobot/internal/model"
+)
+
+// MockCreator is a mock implementation of ReminderCreator for testing
+type MockCreator struct {
+	reminders []*model.Reminder
+}
+
+func (m *MockCreator) CreateReminder(platform, channelID, messageID, replyToID, userID, username, content string, triggerAt time.Time) (*model.Reminder, error) {
+	reminder := &model.Reminder{
+		ID:        int64(len(m.reminders) + 1),
+		Platform:  platform,
+		ChannelID: channelID,
+		MessageID: messageID,
+		ReplyToID: replyToID,
+		UserID:    userID,
+		Username:  username,
+		Content:   content,
+		TriggerAt: triggerAt,
+	}
+	m.reminders = append(m.reminders, reminder)
+	return reminder, nil
+}
+
+func TestReminderOnMessage(t *testing.T) {
+	creator := &MockCreator{reminders: make([]*model.Reminder, 0)}
+	plugin := New(creator)
+
+	tests := []struct {
+		name           string
+		message        *model.Message
+		expectResponse bool
+		expectReminder bool
+	}{
+		{
+			name: "Valid reminder command - years",
+			message: &model.Message{
+				Text:    "!remindme 1y",
+				ReplyTo: "original-message-id",
+				Author:  "testuser",
+				Channel: &model.Channel{Platform: "test"},
+			},
+			expectResponse: true,
+			expectReminder: true,
+		},
+		{
+			name: "Valid reminder command - months",
+			message: &model.Message{
+				Text:    "!remindme 3mo",
+				ReplyTo: "original-message-id",
+				Author:  "testuser",
+				Channel: &model.Channel{Platform: "test"},
+			},
+			expectResponse: true,
+			expectReminder: true,
+		},
+		{
+			name: "Valid reminder command - days",
+			message: &model.Message{
+				Text:    "!remindme 2d",
+				ReplyTo: "original-message-id",
+				Author:  "testuser",
+				Channel: &model.Channel{Platform: "test"},
+			},
+			expectResponse: true,
+			expectReminder: true,
+		},
+		{
+			name: "Valid reminder command - hours",
+			message: &model.Message{
+				Text:    "!remindme 5h",
+				ReplyTo: "original-message-id",
+				Author:  "testuser",
+				Channel: &model.Channel{Platform: "test"},
+			},
+			expectResponse: true,
+			expectReminder: true,
+		},
+		{
+			name: "Valid reminder command - minutes",
+			message: &model.Message{
+				Text:    "!remindme 30m",
+				ReplyTo: "original-message-id",
+				Author:  "testuser",
+				Channel: &model.Channel{Platform: "test"},
+			},
+			expectResponse: true,
+			expectReminder: true,
+		},
+		{
+			name: "Valid reminder command - seconds",
+			message: &model.Message{
+				Text:    "!remindme 60s",
+				ReplyTo: "original-message-id",
+				Author:  "testuser",
+				Channel: &model.Channel{Platform: "test"},
+			},
+			expectResponse: true,
+			expectReminder: true,
+		},
+		{
+			name: "Not a reply",
+			message: &model.Message{
+				Text:    "!remindme 2d",
+				ReplyTo: "",
+				Author:  "testuser",
+				Channel: &model.Channel{Platform: "test"},
+			},
+			expectResponse: false,
+			expectReminder: false,
+		},
+		{
+			name: "Not a reminder command",
+			message: &model.Message{
+				Text:    "hello world",
+				ReplyTo: "original-message-id",
+				Author:  "testuser",
+				Channel: &model.Channel{Platform: "test"},
+			},
+			expectResponse: false,
+			expectReminder: false,
+		},
+		{
+			name: "Invalid duration format",
+			message: &model.Message{
+				Text:    "!remindme abc",
+				ReplyTo: "original-message-id",
+				Author:  "testuser",
+				Channel: &model.Channel{Platform: "test"},
+			},
+			expectResponse: false,
+			expectReminder: false,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			initialCount := len(creator.reminders)
+			responses := plugin.OnMessage(tt.message, nil)
+
+			if tt.expectResponse && len(responses) == 0 {
+				t.Errorf("Expected response, but got none")
+			}
+
+			if !tt.expectResponse && len(responses) > 0 {
+				t.Errorf("Expected no response, but got %d", len(responses))
+			}
+
+			if tt.expectReminder && len(creator.reminders) != initialCount+1 {
+				t.Errorf("Expected reminder to be created, but it wasn't")
+			}
+
+			if !tt.expectReminder && len(creator.reminders) != initialCount {
+				t.Errorf("Expected no reminder to be created, but got %d", len(creator.reminders)-initialCount)
+			}
+		})
+	}
+}
\ No newline at end of file
diff --git a/internal/queue/queue.go b/internal/queue/queue.go
index 668bf60..692816e 100644
--- a/internal/queue/queue.go
+++ b/internal/queue/queue.go
@@ -3,6 +3,9 @@ package queue
 import (
 	"log/slog"
 	"sync"
+	"time"
+
+	"git.nakama.town/fmartingr/butterrobot/internal/model"
 )
 
 // Item represents a queue item
@@ -14,14 +17,19 @@ type Item struct {
 // HandlerFunc defines a function that processes queue items
 type HandlerFunc func(item Item)
 
+// ReminderHandlerFunc defines a function that processes reminder items
+type ReminderHandlerFunc func(reminder *model.Reminder)
+
 // Queue represents a message queue
 type Queue struct {
-	items    chan Item
-	wg       sync.WaitGroup
-	quit     chan struct{}
-	logger   *slog.Logger
-	running  bool
-	runMutex sync.Mutex
+	items           chan Item
+	wg              sync.WaitGroup
+	quit            chan struct{}
+	logger          *slog.Logger
+	running         bool
+	runMutex        sync.Mutex
+	reminderTicker  *time.Ticker
+	reminderHandler ReminderHandlerFunc
 }
 
 // New creates a new Queue instance
@@ -49,6 +57,24 @@ func (q *Queue) Start(handler HandlerFunc) {
 	go q.worker(handler)
 }
 
+// StartReminderScheduler starts the reminder scheduler
+func (q *Queue) StartReminderScheduler(handler ReminderHandlerFunc) {
+	q.runMutex.Lock()
+	defer q.runMutex.Unlock()
+
+	if q.reminderTicker != nil {
+		return
+	}
+
+	q.reminderHandler = handler
+
+	// Check for reminders every minute
+	q.reminderTicker = time.NewTicker(1 * time.Minute)
+
+	q.wg.Add(1)
+	go q.reminderWorker()
+}
+
 // Stop stops processing queue items
 func (q *Queue) Stop() {
 	q.runMutex.Lock()
@@ -59,6 +85,12 @@ func (q *Queue) Stop() {
 	}
 
 	q.running = false
+
+	// Stop reminder ticker if it exists
+	if q.reminderTicker != nil {
+		q.reminderTicker.Stop()
+	}
+
 	close(q.quit)
 	q.wg.Wait()
 }
@@ -96,4 +128,34 @@ func (q *Queue) worker(handler HandlerFunc) {
 			return
 		}
 	}
-}
\ No newline at end of file
+}
+
+// reminderWorker processes reminder items on a schedule
+func (q *Queue) reminderWorker() {
+	defer q.wg.Done()
+
+	for {
+		select {
+		case <-q.reminderTicker.C:
+			// This is triggered every minute to check for pending reminders
+			q.logger.Debug("Checking for pending reminders")
+
+			if q.reminderHandler != nil {
+				// The handler is responsible for fetching and processing reminders
+				func() {
+					defer func() {
+						if r := recover(); r != nil {
+							q.logger.Error("Panic in reminder worker", "error", r)
+						}
+					}()
+
+					// Call the handler with a nil reminder to indicate it should check the database
+					q.reminderHandler(nil)
+				}()
+			}
+		case <-q.quit:
+			// Quit worker
+			return
+		}
+	}
+}

From 323ea4e8cdfc7ac6c2226317629fbd1ff0782f7e Mon Sep 17 00:00:00 2001
From: "Felipe M." <me@fmartingr.com>
Date: Tue, 22 Apr 2025 11:40:10 +0200
Subject: [PATCH 06/11] fix(ci): updated woodpecker triggers

---
 .woodpecker/ci.yml      | 2 +-
 .woodpecker/release.yml | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/.woodpecker/ci.yml b/.woodpecker/ci.yml
index 4353088..5b32d48 100644
--- a/.woodpecker/ci.yml
+++ b/.woodpecker/ci.yml
@@ -3,7 +3,7 @@ when:
     - push
     - pull_request
   branch:
-    - main
+    - master
 
 steps:
   format:
diff --git a/.woodpecker/release.yml b/.woodpecker/release.yml
index 3630566..39dbf65 100644
--- a/.woodpecker/release.yml
+++ b/.woodpecker/release.yml
@@ -1,6 +1,6 @@
 when:
   - event: tag
-    branch: main
+    branch: master
 
 steps:
   - name: Release

From abcd3c3c44b96951d1c3b297741bb7b57499f99b Mon Sep 17 00:00:00 2001
From: "Felipe M." <me@fmartingr.com>
Date: Tue, 22 Apr 2025 11:41:56 +0200
Subject: [PATCH 07/11] docs: updated README

---
 README.md | 7 ++-----
 1 file changed, 2 insertions(+), 5 deletions(-)

diff --git a/README.md b/README.md
index 214afa6..920d087 100644
--- a/README.md
+++ b/README.md
@@ -1,9 +1,6 @@
 # Butter Robot
 
-| Stable | Master |
-| --- | --- |
-| ![Build stable tag docker image](https://git.nakama.town/fmartingr/butterrobot/workflows/Build%20stable%20tag%20docker%20image/badge.svg?branch=stable) | ![Build latest tag docker image](https://git.nakama.town/fmartingr/butterrobot/workflows/Build%20latest%20tag%20docker%20image/badge.svg?branch=master) |
-| ![Test](https://git.nakama.town/fmartingr/butterrobot/workflows/Test/badge.svg?branch=stable) | ![Test](https://git.nakama.town/fmartingr/butterrobot/workflows/Test/badge.svg?branch=master) |
+![Status badge](https://woodpecker.local.fmartingr.dev/api/badges/5/status.svg)
 
 Go framework to create bots for several platforms.
 
@@ -13,7 +10,7 @@ Go framework to create bots for several platforms.
 
 ## Features
 
-- Support for multiple chat platforms (Slack, Telegram)
+- Support for multiple chat platforms (Slack (untested!), Telegram)
 - Plugin system for easy extension
 - Admin interface for managing channels and plugins
 - Message queue for asynchronous processing

From 763a451251c95c609887c64de4eda4fe01bbf39b Mon Sep 17 00:00:00 2001
From: "Felipe M." <me@fmartingr.com>
Date: Tue, 22 Apr 2025 11:56:33 +0200
Subject: [PATCH 08/11] fix: lint errors

---
 internal/admin/admin.go                   | 19 +++++-----------
 internal/app/app.go                       | 18 ++++++++++-----
 internal/db/db.go                         | 27 ++++++++++++++++-------
 internal/migration/migration.go           | 24 +++++++++++++++-----
 internal/platform/slack/slack.go          | 18 ++++++++++-----
 internal/platform/telegram/telegram.go    | 20 +++++++++++++----
 internal/plugin/fun/dice.go               |  5 +++--
 internal/plugin/reminder/reminder.go      |  9 +-------
 internal/plugin/reminder/reminder_test.go |  2 +-
 internal/plugin/social/instagram.go       |  4 +---
 10 files changed, 91 insertions(+), 55 deletions(-)

diff --git a/internal/admin/admin.go b/internal/admin/admin.go
index c2a78ca..e20c7c0 100644
--- a/internal/admin/admin.go
+++ b/internal/admin/admin.go
@@ -194,7 +194,7 @@ func (a *Admin) addFlash(w http.ResponseWriter, r *http.Request, message string,
 	}
 
 	// Map internal categories to Bootstrap alert classes
-	alertClass := category
+	var alertClass string
 	switch category {
 	case "success":
 		alertClass = "success"
@@ -249,16 +249,6 @@ func (a *Admin) getFlashes(w http.ResponseWriter, r *http.Request) []FlashMessag
 	return messages
 }
 
-// requireLogin middleware checks if the user is logged in
-func (a *Admin) requireLogin(next http.HandlerFunc) http.HandlerFunc {
-	return func(w http.ResponseWriter, r *http.Request) {
-		if !a.isLoggedIn(r) {
-			http.Redirect(w, r, "/admin/login", http.StatusSeeOther)
-			return
-		}
-		next(w, r)
-	}
-}
 
 // render renders a template with the given data
 func (a *Admin) render(w http.ResponseWriter, r *http.Request, templateName string, data TemplateData) {
@@ -334,7 +324,10 @@ func (a *Admin) handleLogin(w http.ResponseWriter, r *http.Request) {
 
 		// Set session expiration
 		session.Options.MaxAge = 3600 * 24 * 7 // 1 week
-		session.Save(r, w)
+		err = session.Save(r, w)
+		if err != nil {
+			fmt.Printf("Error saving session: %v\n", err)
+		}
 
 		a.addFlash(w, r, "You were logged in", "success")
 
@@ -715,4 +708,4 @@ func (a *Admin) handleChannelPluginDetailOrDelete(w http.ResponseWriter, r *http
 
 	// Redirect to channel plugins list
 	http.Redirect(w, r, "/admin/channelplugins", http.StatusSeeOther)
-}
+}
\ No newline at end of file
diff --git a/internal/app/app.go b/internal/app/app.go
index 1d878ab..ece6908 100644
--- a/internal/app/app.go
+++ b/internal/app/app.go
@@ -152,7 +152,9 @@ func (a *App) initializeRoutes() {
 	a.router.HandleFunc("/healthz", func(w http.ResponseWriter, r *http.Request) {
 		w.Header().Set("Content-Type", "application/json")
 		w.WriteHeader(http.StatusOK)
-		json.NewEncoder(w).Encode(map[string]interface{}{})
+		if err := json.NewEncoder(w).Encode(map[string]interface{}{}); err != nil {
+			a.logger.Error("Error encoding response", "error", err)
+		}
 	})
 
 	// Platform webhook endpoints
@@ -175,7 +177,9 @@ func (a *App) handleIncomingWebhook(w http.ResponseWriter, r *http.Request) {
 	if _, err := platform.Get(platformName); err != nil {
 		w.Header().Set("Content-Type", "application/json")
 		w.WriteHeader(http.StatusBadRequest)
-		json.NewEncoder(w).Encode(map[string]string{"error": "Unknown platform"})
+		if err := json.NewEncoder(w).Encode(map[string]string{"error": "Unknown platform"}); err != nil {
+			a.logger.Error("Error encoding response", "error", err)
+		}
 		return
 	}
 
@@ -184,7 +188,9 @@ func (a *App) handleIncomingWebhook(w http.ResponseWriter, r *http.Request) {
 	if err != nil {
 		w.Header().Set("Content-Type", "application/json")
 		w.WriteHeader(http.StatusBadRequest)
-		json.NewEncoder(w).Encode(map[string]string{"error": "Failed to read request body"})
+		if err := json.NewEncoder(w).Encode(map[string]string{"error": "Failed to read request body"}); err != nil {
+			a.logger.Error("Error encoding response", "error", err)
+		}
 		return
 	}
 
@@ -200,7 +206,9 @@ func (a *App) handleIncomingWebhook(w http.ResponseWriter, r *http.Request) {
 	// Respond with success
 	w.Header().Set("Content-Type", "application/json")
 	w.WriteHeader(http.StatusOK)
-	json.NewEncoder(w).Encode(map[string]any{})
+	if err := json.NewEncoder(w).Encode(map[string]any{}); err != nil {
+		a.logger.Error("Error encoding response", "error", err)
+	}
 }
 
 // extractPlatformName extracts the platform name from the URL path
@@ -382,4 +390,4 @@ func (a *App) processReminder(reminder *model.Reminder) {
 	if err := a.db.MarkReminderAsProcessed(reminder.ID); err != nil {
 		a.logger.Error("Error marking reminder as processed", "error", err)
 	}
-}
+}
\ No newline at end of file
diff --git a/internal/db/db.go b/internal/db/db.go
index b71b543..328d460 100644
--- a/internal/db/db.go
+++ b/internal/db/db.go
@@ -234,7 +234,11 @@ func (d *Database) GetChannelPlugins(channelID int64) ([]*model.ChannelPlugin, e
 	if err != nil {
 		return nil, err
 	}
-	defer rows.Close()
+	defer func() {
+		if err := rows.Close(); err != nil {
+			fmt.Printf("Error closing rows: %v\n", err)
+		}
+	}()
 
 	var plugins []*model.ChannelPlugin
 
@@ -415,7 +419,11 @@ func (d *Database) GetAllChannels() ([]*model.Channel, error) {
 	if err != nil {
 		return nil, err
 	}
-	defer rows.Close()
+	defer func() {
+		if err := rows.Close(); err != nil {
+			fmt.Printf("Error closing rows: %v\n", err)
+		}
+	}()
 
 	var channels []*model.Channel
 
@@ -454,10 +462,9 @@ func (d *Database) GetAllChannels() ([]*model.Channel, error) {
 			continue // Skip this channel if plugins can't be retrieved
 		}
 
-		if plugins != nil {
-			for _, plugin := range plugins {
-				channel.Plugins[plugin.PluginID] = plugin
-			}
+		// Add plugins to channel
+		for _, plugin := range plugins {
+			channel.Plugins[plugin.PluginID] = plugin
 		}
 
 		channels = append(channels, channel)
@@ -646,7 +653,11 @@ func (d *Database) GetPendingReminders() ([]*model.Reminder, error) {
 	if err != nil {
 		return nil, err
 	}
-	defer rows.Close()
+	defer func() {
+		if err := rows.Close(); err != nil {
+			fmt.Printf("Error closing rows: %v\n", err)
+		}
+	}()
 
 	var reminders []*model.Reminder
 
@@ -763,4 +774,4 @@ func initDatabase(db *sql.DB) error {
 	}
 
 	return nil
-}
+}
\ No newline at end of file
diff --git a/internal/migration/migration.go b/internal/migration/migration.go
index dec4ff5..2067755 100644
--- a/internal/migration/migration.go
+++ b/internal/migration/migration.go
@@ -49,7 +49,11 @@ func GetAppliedMigrations(db *sql.DB) ([]int, error) {
 	if err != nil {
 		return nil, err
 	}
-	defer rows.Close()
+	defer func() {
+		if err := rows.Close(); err != nil {
+			fmt.Printf("Error closing rows: %v\n", err)
+		}
+	}()
 
 	var versions []int
 	for rows.Next() {
@@ -128,7 +132,9 @@ func Migrate(db *sql.DB) error {
 
 			// Apply the migration
 			if err := migration.Up(db); err != nil {
-				tx.Rollback()
+				if err := tx.Rollback(); err != nil {
+					fmt.Printf("Error rolling back transaction: %v\n", err)
+				}
 				return fmt.Errorf("failed to apply migration %d: %w", version, err)
 			}
 
@@ -137,7 +143,9 @@ func Migrate(db *sql.DB) error {
 				"INSERT INTO schema_migrations (version, applied_at) VALUES (?, ?)",
 				version, time.Now(),
 			); err != nil {
-				tx.Rollback()
+				if err := tx.Rollback(); err != nil {
+					fmt.Printf("Error rolling back transaction: %v\n", err)
+				}
 				return fmt.Errorf("failed to mark migration %d as applied: %w", version, err)
 			}
 
@@ -188,13 +196,17 @@ func MigrateDown(db *sql.DB, targetVersion int) error {
 
 			// Apply the down migration
 			if err := migration.Down(db); err != nil {
-				tx.Rollback()
+				if err := tx.Rollback(); err != nil {
+					fmt.Printf("Error rolling back transaction: %v\n", err)
+				}
 				return fmt.Errorf("failed to roll back migration %d: %w", version, err)
 			}
 
 			// Remove from applied list
 			if _, err := tx.Exec("DELETE FROM schema_migrations WHERE version = ?", version); err != nil {
-				tx.Rollback()
+				if err := tx.Rollback(); err != nil {
+					fmt.Printf("Error rolling back transaction: %v\n", err)
+				}
 				return fmt.Errorf("failed to remove migration %d from applied list: %w", version, err)
 			}
 
@@ -208,4 +220,4 @@ func MigrateDown(db *sql.DB, targetVersion int) error {
 	}
 
 	return nil
-}
+}
\ No newline at end of file
diff --git a/internal/platform/slack/slack.go b/internal/platform/slack/slack.go
index 3683ada..efa7c5d 100644
--- a/internal/platform/slack/slack.go
+++ b/internal/platform/slack/slack.go
@@ -4,7 +4,7 @@ import (
 	"encoding/json"
 	"errors"
 	"fmt"
-	"io/ioutil"
+	"io"
 	"net/http"
 	"strings"
 	"time"
@@ -37,11 +37,15 @@ func (s *SlackPlatform) Init(_ *config.Config) error {
 // ParseIncomingMessage parses an incoming Slack message
 func (s *SlackPlatform) ParseIncomingMessage(r *http.Request) (*model.Message, error) {
 	// Read request body
-	body, err := ioutil.ReadAll(r.Body)
+	body, err := io.ReadAll(r.Body)
 	if err != nil {
 		return nil, err
 	}
-	defer r.Body.Close()
+	defer func() {
+		if err := r.Body.Close(); err != nil {
+			fmt.Printf("Error closing request body: %v\n", err)
+		}
+	}()
 
 	// Parse JSON
 	var requestData map[string]interface{}
@@ -194,7 +198,11 @@ func (s *SlackPlatform) SendMessage(msg *model.Message) error {
 	if err != nil {
 		return err
 	}
-	defer resp.Body.Close()
+	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 {
@@ -209,4 +217,4 @@ func parseInt64(s string) (int64, error) {
 	var n int64
 	_, err := fmt.Sscanf(s, "%d", &n)
 	return n, err
-}
+}
\ No newline at end of file
diff --git a/internal/platform/telegram/telegram.go b/internal/platform/telegram/telegram.go
index 6c9a2b3..baf26d0 100644
--- a/internal/platform/telegram/telegram.go
+++ b/internal/platform/telegram/telegram.go
@@ -62,7 +62,11 @@ func (t *TelegramPlatform) Init(cfg *config.Config) error {
 		t.log.Error("Failed to set webhook", "error", err)
 		return fmt.Errorf("failed to set webhook: %w", err)
 	}
-	defer resp.Body.Close()
+	defer func() {
+		if err := resp.Body.Close(); err != nil {
+			t.log.Error("Error closing response body", "error", err)
+		}
+	}()
 
 	if resp.StatusCode != http.StatusOK {
 		bodyBytes, _ := io.ReadAll(resp.Body)
@@ -85,7 +89,11 @@ func (t *TelegramPlatform) ParseIncomingMessage(r *http.Request) (*model.Message
 		t.log.Error("Failed to read request body", "error", err)
 		return nil, err
 	}
-	defer r.Body.Close()
+	defer func() {
+		if err := r.Body.Close(); err != nil {
+			t.log.Error("Error closing request body", "error", err)
+		}
+	}()
 
 	// Parse JSON
 	var update struct {
@@ -251,7 +259,11 @@ func (t *TelegramPlatform) SendMessage(msg *model.Message) error {
 		t.log.Error("Failed to send message", "error", err)
 		return err
 	}
-	defer resp.Body.Close()
+	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 {
@@ -263,4 +275,4 @@ func (t *TelegramPlatform) SendMessage(msg *model.Message) error {
 
 	t.log.Debug("Message sent successfully")
 	return nil
-}
+}
\ No newline at end of file
diff --git a/internal/plugin/fun/dice.go b/internal/plugin/fun/dice.go
index 00fc7cc..2d5533b 100644
--- a/internal/plugin/fun/dice.go
+++ b/internal/plugin/fun/dice.go
@@ -107,9 +107,10 @@ func (p *DicePlugin) rollDice(formula string) (int, error) {
 			return 0, fmt.Errorf("invalid modifier")
 		}
 
-		if matches[3] == "+" {
+		switch matches[3] {
+		case "+":
 			total += modifier
-		} else if matches[3] == "-" {
+		case "-":
 			total -= modifier
 		}
 	}
diff --git a/internal/plugin/reminder/reminder.go b/internal/plugin/reminder/reminder.go
index 6d7c1aa..5eb47f9 100644
--- a/internal/plugin/reminder/reminder.go
+++ b/internal/plugin/reminder/reminder.go
@@ -44,14 +44,7 @@ func New(creator ReminderCreator) *Reminder {
 func (r *Reminder) OnMessage(msg *model.Message, config map[string]interface{}) []*model.Message {
 	// Only process replies to messages
 	if msg.ReplyTo == "" {
-		return []*model.Message{
-			{
-				Text:    "Please reply to a message with `!remindme <duration>` to set a reminder.",
-				Chat:    msg.Chat,
-				Channel: msg.Channel,
-				ReplyTo: msg.ID,
-			},
-		}
+		return nil
 	}
 
 	// Check if the message is a reminder command
diff --git a/internal/plugin/reminder/reminder_test.go b/internal/plugin/reminder/reminder_test.go
index b76fd2f..3070918 100644
--- a/internal/plugin/reminder/reminder_test.go
+++ b/internal/plugin/reminder/reminder_test.go
@@ -161,4 +161,4 @@ func TestReminderOnMessage(t *testing.T) {
 			}
 		})
 	}
-}
\ No newline at end of file
+}
diff --git a/internal/plugin/social/instagram.go b/internal/plugin/social/instagram.go
index a4f758a..7ff74a5 100644
--- a/internal/plugin/social/instagram.go
+++ b/internal/plugin/social/instagram.go
@@ -53,9 +53,7 @@ func (p *InstagramExpander) OnMessage(msg *model.Message, config map[string]inte
 		}
 
 		// Change the host
-		if strings.Contains(parsedURL.Host, "instagram.com") {
-			parsedURL.Host = strings.Replace(parsedURL.Host, "instagram.com", "ddinstagram.com", 1)
-		}
+		parsedURL.Host = strings.Replace(parsedURL.Host, "instagram.com", "ddinstagram.com", 1)
 
 		// Remove query parameters
 		parsedURL.RawQuery = ""

From c9edb57505314aa573d3bdddd1aa2e96abdc76de Mon Sep 17 00:00:00 2001
From: "Felipe M." <me@fmartingr.com>
Date: Tue, 22 Apr 2025 11:56:57 +0200
Subject: [PATCH 09/11] fix: make format

---
 internal/admin/admin.go                | 3 +--
 internal/app/app.go                    | 2 +-
 internal/db/db.go                      | 2 +-
 internal/migration/migration.go        | 2 +-
 internal/platform/slack/slack.go       | 2 +-
 internal/platform/telegram/telegram.go | 2 +-
 6 files changed, 6 insertions(+), 7 deletions(-)

diff --git a/internal/admin/admin.go b/internal/admin/admin.go
index e20c7c0..69c769b 100644
--- a/internal/admin/admin.go
+++ b/internal/admin/admin.go
@@ -249,7 +249,6 @@ func (a *Admin) getFlashes(w http.ResponseWriter, r *http.Request) []FlashMessag
 	return messages
 }
 
-
 // render renders a template with the given data
 func (a *Admin) render(w http.ResponseWriter, r *http.Request, templateName string, data TemplateData) {
 	// Add current user data
@@ -708,4 +707,4 @@ func (a *Admin) handleChannelPluginDetailOrDelete(w http.ResponseWriter, r *http
 
 	// Redirect to channel plugins list
 	http.Redirect(w, r, "/admin/channelplugins", http.StatusSeeOther)
-}
\ No newline at end of file
+}
diff --git a/internal/app/app.go b/internal/app/app.go
index ece6908..7403396 100644
--- a/internal/app/app.go
+++ b/internal/app/app.go
@@ -390,4 +390,4 @@ func (a *App) processReminder(reminder *model.Reminder) {
 	if err := a.db.MarkReminderAsProcessed(reminder.ID); err != nil {
 		a.logger.Error("Error marking reminder as processed", "error", err)
 	}
-}
\ No newline at end of file
+}
diff --git a/internal/db/db.go b/internal/db/db.go
index 328d460..bdf9eaf 100644
--- a/internal/db/db.go
+++ b/internal/db/db.go
@@ -774,4 +774,4 @@ func initDatabase(db *sql.DB) error {
 	}
 
 	return nil
-}
\ No newline at end of file
+}
diff --git a/internal/migration/migration.go b/internal/migration/migration.go
index 2067755..63da5d8 100644
--- a/internal/migration/migration.go
+++ b/internal/migration/migration.go
@@ -220,4 +220,4 @@ func MigrateDown(db *sql.DB, targetVersion int) error {
 	}
 
 	return nil
-}
\ No newline at end of file
+}
diff --git a/internal/platform/slack/slack.go b/internal/platform/slack/slack.go
index efa7c5d..9c12b1f 100644
--- a/internal/platform/slack/slack.go
+++ b/internal/platform/slack/slack.go
@@ -217,4 +217,4 @@ func parseInt64(s string) (int64, error) {
 	var n int64
 	_, err := fmt.Sscanf(s, "%d", &n)
 	return n, err
-}
\ No newline at end of file
+}
diff --git a/internal/platform/telegram/telegram.go b/internal/platform/telegram/telegram.go
index baf26d0..0edb729 100644
--- a/internal/platform/telegram/telegram.go
+++ b/internal/platform/telegram/telegram.go
@@ -275,4 +275,4 @@ func (t *TelegramPlatform) SendMessage(msg *model.Message) error {
 
 	t.log.Debug("Message sent successfully")
 	return nil
-}
\ No newline at end of file
+}

From 7dd02c0056b2fc3a6536e727bf2124361bef8bbc Mon Sep 17 00:00:00 2001
From: "Felipe M." <me@fmartingr.com>
Date: Tue, 22 Apr 2025 18:09:27 +0200
Subject: [PATCH 10/11] feat: domain blocker plugin

---
 cmd/butterrobot/main.go                       |   2 +-
 docs/creating-a-plugin.md                     | 124 ++++++++++++++++
 docs/plugins.md                               |   4 +
 internal/admin/admin.go                       |  92 ++++++++++++
 internal/admin/templates/channel_detail.html  |   4 +
 .../templates/channel_plugin_config.html      |  37 +++++
 .../admin/templates/channel_plugins_list.html |   6 +-
 internal/app/app.go                           |  41 +++--
 internal/db/db.go                             |  18 +++
 internal/model/message.go                     |  22 ++-
 internal/model/platform.go                    |   3 +
 internal/model/plugin.go                      |   4 +-
 internal/platform/slack/slack.go              |  63 ++++++++
 internal/platform/telegram/telegram.go        |  92 ++++++++++++
 internal/plugin/domainblock/domainblock.go    | 132 +++++++++++++++++
 .../plugin/domainblock/domainblock_test.go    | 140 ++++++++++++++++++
 internal/plugin/fun/coin.go                   |  11 +-
 internal/plugin/fun/dice.go                   |  11 +-
 internal/plugin/fun/loquito.go                |  11 +-
 internal/plugin/ping/ping.go                  |  13 +-
 internal/plugin/plugin.go                     |   7 +-
 internal/plugin/reminder/reminder.go          |  81 ++++++----
 internal/plugin/reminder/reminder_test.go     |  21 ++-
 internal/plugin/social/instagram.go           |  11 +-
 internal/plugin/social/twitter.go             |  11 +-
 25 files changed, 898 insertions(+), 63 deletions(-)
 create mode 100644 internal/admin/templates/channel_plugin_config.html
 create mode 100644 internal/plugin/domainblock/domainblock.go
 create mode 100644 internal/plugin/domainblock/domainblock_test.go

diff --git a/cmd/butterrobot/main.go b/cmd/butterrobot/main.go
index 3bc56cb..bf217de 100644
--- a/cmd/butterrobot/main.go
+++ b/cmd/butterrobot/main.go
@@ -45,4 +45,4 @@ func main() {
 		logger.Error("Application error", "error", err)
 		os.Exit(1)
 	}
-}
+}
\ No newline at end of file
diff --git a/docs/creating-a-plugin.md b/docs/creating-a-plugin.md
index 469491a..b8e4a78 100644
--- a/docs/creating-a-plugin.md
+++ b/docs/creating-a-plugin.md
@@ -7,6 +7,7 @@ ButterRobot organizes plugins into different categories:
 - **Development**: Utility plugins like `ping`
 - **Fun**: Entertainment plugins like dice rolling, coin flipping
 - **Social**: Social media related plugins like URL transformers/expanders
+- **Security**: Moderation and protection features like domain blocking
 
 When creating a new plugin, consider which category it fits into and place it in the appropriate directory.
 
@@ -59,6 +60,91 @@ func (p *MarcoPlugin) OnMessage(msg *model.Message, config map[string]interface{
 }
 ```
 
+### Configuration-Enabled Plugin
+
+This plugin requires configuration to be set in the admin interface. It demonstrates how to create plugins that need channel-specific configuration:
+
+```go
+package security
+
+import (
+	"fmt"
+	"regexp"
+	"strings"
+
+	"git.nakama.town/fmartingr/butterrobot/internal/model"
+	"git.nakama.town/fmartingr/butterrobot/internal/plugin"
+)
+
+// DomainBlockPlugin is a plugin that blocks messages containing links from specific domains
+type DomainBlockPlugin struct {
+	plugin.BasePlugin
+}
+
+// New creates a new DomainBlockPlugin instance
+func New() *DomainBlockPlugin {
+	return &DomainBlockPlugin{
+		BasePlugin: plugin.BasePlugin{
+			ID:             "security.domainblock",
+			Name:           "Domain Blocker",
+			Help:           "Blocks messages containing links from configured domains",
+			ConfigRequired: true, // Mark this plugin as requiring configuration
+		},
+	}
+}
+
+// OnMessage processes incoming messages
+func (p *DomainBlockPlugin) OnMessage(msg *model.Message, config map[string]interface{}) []*model.Message {
+	// Get blocked domains from config
+	blockedDomainsStr, ok := config["blocked_domains"].(string)
+	if !ok || blockedDomainsStr == "" {
+		return nil // No blocked domains configured
+	}
+
+	// Split and clean blocked domains
+	blockedDomains := strings.Split(blockedDomainsStr, ",")
+	for i, domain := range blockedDomains {
+		blockedDomains[i] = strings.ToLower(strings.TrimSpace(domain))
+	}
+
+	// Extract domains from message
+	urlRegex := regexp.MustCompile(`https?://([^\s/$.?#].[^\s]*)`)
+	matches := urlRegex.FindAllStringSubmatch(msg.Text, -1)
+	
+	// Check if any extracted domains are blocked
+	for _, match := range matches {
+		if len(match) < 2 {
+			continue
+		}
+		
+		domain := strings.ToLower(match[1])
+		
+		for _, blockedDomain := range blockedDomains {
+			if blockedDomain == "" {
+				continue
+			}
+			
+			if strings.HasSuffix(domain, blockedDomain) || domain == blockedDomain {
+				// Domain is blocked, create warning message
+				response := &model.Message{
+					Text:    fmt.Sprintf("⚠️ Message contained a link to blocked domain: %s", blockedDomain),
+					Chat:    msg.Chat,
+					ReplyTo: msg.ID,
+					Channel: msg.Channel,
+				}
+				return []*model.Message{response}
+			}
+		}
+	}
+
+	return nil
+}
+
+func init() {
+	plugin.Register(New())
+}
+```
+
 ### Advanced Example: URL Transformer
 
 This more complex plugin transforms URLs, useful for improving media embedding in chat platforms:
@@ -143,6 +229,36 @@ func (p *TwitterExpander) OnMessage(msg *model.Message, config map[string]interf
 }
 ```
 
+## Enabling Configuration for Plugins
+
+To indicate that your plugin requires configuration:
+
+1. Set `ConfigRequired: true` in the BasePlugin struct:
+   ```go
+   BasePlugin: plugin.BasePlugin{
+       ID:             "myplugin.id",
+       Name:           "Plugin Name",
+       Help:           "Help text",
+       ConfigRequired: true,
+   },
+   ```
+
+2. Access the configuration in the OnMessage method:
+   ```go
+   func (p *MyPlugin) OnMessage(msg *model.Message, config map[string]interface{}) []*model.Message {
+       // Extract configuration values
+       configValue, ok := config["some_config_key"].(string)
+       if !ok || configValue == "" {
+           // Handle missing or empty configuration
+           return nil
+       }
+       
+       // Use the configuration...
+   }
+   ```
+
+3. The admin interface will show a "Configure" button for plugins that require configuration.
+
 ## Registering Plugins
 
 To use the plugin, register it in your application:
@@ -161,3 +277,11 @@ func (a *App) Run() error {
     // ...
 }
 ```
+
+Alternatively, you can register your plugin in its init() function:
+
+```go
+func init() {
+    plugin.Register(New())
+}
+```
diff --git a/docs/plugins.md b/docs/plugins.md
index 84578e5..25df16c 100644
--- a/docs/plugins.md
+++ b/docs/plugins.md
@@ -14,6 +14,10 @@
 
 - Remind Me: Reply to a message with `!remindme <duration>` to set a reminder. Supported duration units: y (years), mo (months), d (days), h (hours), m (minutes), s (seconds). Examples: `!remindme 1y` for 1 year, `!remindme 3mo` for 3 months, `!remindme 2d` for 2 days, `!remindme 3h` for 3 hours. The bot will mention you with a reminder after the specified time.
 
+### Security
+
+- Domain Blocker: Blocks messages containing links from specified domains. Configure it per channel with a comma-separated list of domains to block. When a message contains a link matching any of the blocked domains, the bot will notify that the message contained a blocked domain. This plugin requires configuration through the admin interface.
+
 ### Social Media
 
 - Twitter Link Expander: Automatically converts twitter.com and x.com links to fxtwitter.com links and removes tracking parameters. This allows for better media embedding in chat platforms.
diff --git a/internal/admin/admin.go b/internal/admin/admin.go
index 69c769b..dee4197 100644
--- a/internal/admin/admin.go
+++ b/internal/admin/admin.go
@@ -98,6 +98,7 @@ func New(cfg *config.Config, database *db.Database, version string) *Admin {
 		"channel_detail.html",
 		"plugin_list.html",
 		"channel_plugins_list.html",
+		"channel_plugin_config.html",
 	}
 
 	for _, tf := range templateFiles {
@@ -143,6 +144,7 @@ func (a *Admin) RegisterRoutes(mux *http.ServeMux) {
 	mux.HandleFunc("/admin/channels", a.handleChannelList)
 	mux.HandleFunc("/admin/channels/", a.handleChannelDetail)
 	mux.HandleFunc("/admin/channelplugins", a.handleChannelPluginList)
+	mux.HandleFunc("/admin/channelplugins/config/", a.handleChannelPluginConfig)
 	mux.HandleFunc("/admin/channelplugins/", a.handleChannelPluginDetailOrDelete)
 }
 
@@ -628,6 +630,96 @@ func (a *Admin) handleChannelPluginList(w http.ResponseWriter, r *http.Request)
 	})
 }
 
+// handleChannelPluginConfig handles the channel plugin configuration route
+func (a *Admin) handleChannelPluginConfig(w http.ResponseWriter, r *http.Request) {
+	// Check if user is logged in
+	if !a.isLoggedIn(r) {
+		http.Redirect(w, r, "/admin/login", http.StatusSeeOther)
+		return
+	}
+
+	// Extract channel plugin ID from path
+	path := r.URL.Path
+	channelPluginID := strings.TrimPrefix(path, "/admin/channelplugins/config/")
+
+	// Convert channel plugin ID to int64
+	id, err := strconv.ParseInt(channelPluginID, 10, 64)
+	if err != nil {
+		http.Error(w, "Invalid channel plugin ID", http.StatusBadRequest)
+		return
+	}
+
+	// Get the channel plugin
+	channelPlugin, err := a.db.GetChannelPluginByID(id)
+	if err != nil {
+		http.Error(w, "Channel plugin not found", http.StatusNotFound)
+		return
+	}
+
+	// Get the plugin
+	p, err := plugin.Get(channelPlugin.PluginID)
+	if err != nil {
+		http.Error(w, "Plugin not found", http.StatusNotFound)
+		return
+	}
+
+	// Handle form submission
+	if r.Method == http.MethodPost {
+		// Parse form
+		if err := r.ParseForm(); err != nil {
+			http.Error(w, "Bad request", http.StatusBadRequest)
+			return
+		}
+
+		// Create config map from form values
+		config := make(map[string]interface{})
+		
+		// Process form values based on plugin type
+		if channelPlugin.PluginID == "security.domainblock" {
+			// Get blocked domains from form
+			blockedDomains := r.FormValue("blocked_domains")
+			config["blocked_domains"] = blockedDomains
+		} else {
+			// Generic handling for other plugins
+			for key, values := range r.Form {
+				if key == "form_submitted" {
+					continue
+				}
+				if len(values) == 1 {
+					config[key] = values[0]
+				} else {
+					config[key] = values
+				}
+			}
+		}
+
+		// Update plugin configuration
+		if err := a.db.UpdateChannelPluginConfig(id, config); err != nil {
+			http.Error(w, "Failed to update plugin configuration", http.StatusInternalServerError)
+			return
+		}
+
+		// Get the channel to redirect back to the channel detail page
+		channel, err := a.db.GetChannelByID(channelPlugin.ChannelID)
+		if err != nil {
+			a.addFlash(w, r, "Plugin configuration updated", "success")
+			http.Redirect(w, r, "/admin/channelplugins", http.StatusSeeOther)
+			return
+		}
+
+		a.addFlash(w, r, "Plugin configuration updated", "success")
+		http.Redirect(w, r, fmt.Sprintf("/admin/channels/%d", channel.ID), http.StatusSeeOther)
+		return
+	}
+
+	// Render template
+	a.render(w, r, "channel_plugin_config.html", TemplateData{
+		Title:         "Configure Plugin: " + p.GetName(),
+		ChannelPlugin: channelPlugin,
+		Plugins:       map[string]model.Plugin{channelPlugin.PluginID: p},
+	})
+}
+
 // handleChannelPluginDetailOrDelete handles the channel plugin detail or delete route
 func (a *Admin) handleChannelPluginDetailOrDelete(w http.ResponseWriter, r *http.Request) {
 	// Check if user is logged in
diff --git a/internal/admin/templates/channel_detail.html b/internal/admin/templates/channel_detail.html
index 764d7b1..78909df 100644
--- a/internal/admin/templates/channel_detail.html
+++ b/internal/admin/templates/channel_detail.html
@@ -68,6 +68,10 @@
                                             {{if $channelPlugin.Enabled}}Disable{{else}}Enable{{end}}
                                         </button>
                                     </form>
+                                    {{$plugin := index $.Plugins $pluginID}}
+                                    {{if $plugin.RequiresConfig}}
+                                    <a href="/admin/channelplugins/config/{{$channelPlugin.ID}}" class="btn btn-info btn-sm">Configure</a>
+                                    {{end}}
                                     <form method="post" action="/admin/channelplugins/{{$channelPlugin.ID}}/delete" class="d-inline">
                                         <button type="submit" class="btn btn-danger btn-sm"
                                             onclick="return confirm('Are you sure you want to remove this plugin?')">Remove</button>
diff --git a/internal/admin/templates/channel_plugin_config.html b/internal/admin/templates/channel_plugin_config.html
new file mode 100644
index 0000000..decf1a2
--- /dev/null
+++ b/internal/admin/templates/channel_plugin_config.html
@@ -0,0 +1,37 @@
+{{define "content"}}
+<div class="row">
+    <div class="col-md-12">
+        <div class="card">
+            <div class="card-header">
+                <h3 class="card-title">Configure Plugin: {{(index .Plugins .ChannelPlugin.PluginID).GetName}}</h3>
+            </div>
+            <div class="card-body">
+                <form method="post">
+                    <!-- Plugin configuration fields -->
+                    {{if eq .ChannelPlugin.PluginID "security.domainblock"}}
+                    <div class="mb-3">
+                        <label class="form-label">Blocked Domains</label>
+                        <input type="text" class="form-control" name="blocked_domains"
+                               value="{{with .ChannelPlugin.Config}}{{index . "blocked_domains"}}{{end}}"
+                               placeholder="example.com, evil.org, ads.com">
+                        <div class="form-text text-muted">
+                            Enter comma-separated list of domains to block (e.g., example.com, evil.org).
+                            Messages containing links to these domains will be blocked.
+                        </div>
+                    </div>
+                    {{else}}
+                    <div class="alert alert-warning">
+                        This plugin doesn't have specific configuration fields implemented yet.
+                    </div>
+                    {{end}}
+
+                    <div class="form-footer">
+                        <button type="submit" class="btn btn-primary">Save Configuration</button>
+                        <a href="/admin/channels/{{.ChannelPlugin.ChannelID}}" class="btn btn-secondary">Cancel</a>
+                    </div>
+                </form>
+            </div>
+        </div>
+    </div>
+</div>
+{{end}}
diff --git a/internal/admin/templates/channel_plugins_list.html b/internal/admin/templates/channel_plugins_list.html
index b57c60e..485150b 100644
--- a/internal/admin/templates/channel_plugins_list.html
+++ b/internal/admin/templates/channel_plugins_list.html
@@ -38,6 +38,10 @@
                                                 {{if $channelPlugin.Enabled}}Disable{{else}}Enable{{end}}
                                             </button>
                                         </form>
+                                        {{$plugin := index $.Plugins $pluginID}}
+                                        {{if $plugin.ConfigRequired}}
+                                            <a href="/admin/channelplugins/config/{{$channelPlugin.ID}}" class="btn btn-info btn-sm">Configure</a>
+                                        {{end}}
                                         <form method="post" action="/admin/channelplugins/{{$channelPlugin.ID}}/delete" class="d-inline">
                                             <button type="submit" class="btn btn-danger btn-sm"
                                                 onclick="return confirm('Are you sure you want to remove this plugin?')">Remove</button>
@@ -90,4 +94,4 @@
         </div>
     </div>
 </div>
-{{end}}
\ No newline at end of file
+{{end}}
diff --git a/internal/app/app.go b/internal/app/app.go
index 7403396..bd64b80 100644
--- a/internal/app/app.go
+++ b/internal/app/app.go
@@ -20,6 +20,7 @@ import (
 	"git.nakama.town/fmartingr/butterrobot/internal/model"
 	"git.nakama.town/fmartingr/butterrobot/internal/platform"
 	"git.nakama.town/fmartingr/butterrobot/internal/plugin"
+	"git.nakama.town/fmartingr/butterrobot/internal/plugin/domainblock"
 	"git.nakama.town/fmartingr/butterrobot/internal/plugin/fun"
 	"git.nakama.town/fmartingr/butterrobot/internal/plugin/ping"
 	"git.nakama.town/fmartingr/butterrobot/internal/plugin/reminder"
@@ -87,10 +88,8 @@ func (a *App) Run() error {
 	plugin.Register(fun.NewLoquito())
 	plugin.Register(social.NewTwitterExpander())
 	plugin.Register(social.NewInstagramExpander())
-
-	// Register reminder plugin
-	reminderPlugin := reminder.New(a.db)
-	plugin.Register(reminderPlugin)
+	plugin.Register(reminder.New(a.db))
+	plugin.Register(domainblock.New())
 
 	// Initialize routes
 	a.initializeRoutes()
@@ -304,19 +303,39 @@ func (a *App) handleMessage(item queue.Item) {
 			continue
 		}
 
-		// Process message
-		responses := p.OnMessage(message, channelPlugin.Config)
+		// Process message and get actions
+		actions := p.OnMessage(message, channelPlugin.Config)
 
-		// Send responses
+		// Get platform for processing actions
 		platform, err := platform.Get(item.Platform)
 		if err != nil {
 			a.logger.Error("Error getting platform", "error", err)
 			continue
 		}
 
-		for _, response := range responses {
-			if err := platform.SendMessage(response); err != nil {
-				a.logger.Error("Error sending message", "error", err)
+		// Process each action
+		for _, action := range actions {
+			switch action.Type {
+			case model.ActionSendMessage:
+				// Send a message
+				if action.Message != nil {
+					if err := platform.SendMessage(action.Message); err != nil {
+						a.logger.Error("Error sending message", "error", err)
+					}
+				} else {
+					a.logger.Error("Send message action with nil message")
+				}
+				
+			case model.ActionDeleteMessage:
+				// Delete a message using direct DeleteMessage call
+				if err := platform.DeleteMessage(action.Chat, action.MessageID); err != nil {
+					a.logger.Error("Error deleting message", "error", err, "message_id", action.MessageID)
+				} else {
+					a.logger.Info("Message deleted", "message_id", action.MessageID)
+				}
+				
+			default:
+				a.logger.Error("Unknown action type", "type", action.Type)
 			}
 		}
 	}
@@ -390,4 +409,4 @@ func (a *App) processReminder(reminder *model.Reminder) {
 	if err := a.db.MarkReminderAsProcessed(reminder.ID); err != nil {
 		a.logger.Error("Error marking reminder as processed", "error", err)
 	}
-}
+}
\ No newline at end of file
diff --git a/internal/db/db.go b/internal/db/db.go
index bdf9eaf..0da285e 100644
--- a/internal/db/db.go
+++ b/internal/db/db.go
@@ -386,6 +386,24 @@ func (d *Database) UpdateChannelPlugin(id int64, enabled bool) error {
 	return err
 }
 
+// UpdateChannelPluginConfig updates a channel plugin's configuration
+func (d *Database) UpdateChannelPluginConfig(id int64, config map[string]interface{}) error {
+	// Convert config to JSON
+	configJSON, err := json.Marshal(config)
+	if err != nil {
+		return err
+	}
+
+	query := `
+		UPDATE channel_plugin
+		SET config = ?
+		WHERE id = ?
+	`
+
+	_, err = d.db.Exec(query, string(configJSON), id)
+	return err
+}
+
 // DeleteChannelPlugin deletes a channel plugin
 func (d *Database) DeleteChannelPlugin(id int64) error {
 	query := `
diff --git a/internal/model/message.go b/internal/model/message.go
index e6f86f6..ea3b316 100644
--- a/internal/model/message.go
+++ b/internal/model/message.go
@@ -4,6 +4,26 @@ import (
 	"time"
 )
 
+// ActionType defines the type of action to perform
+type ActionType string
+
+const (
+	// ActionSendMessage is for sending a message to the chat
+	ActionSendMessage ActionType = "send_message"
+	// ActionDeleteMessage is for deleting a message from the chat
+	ActionDeleteMessage ActionType = "delete_message"
+)
+
+// MessageAction represents an action to be performed on the platform
+type MessageAction struct {
+	Type      ActionType
+	Message   *Message   // For send_message
+	MessageID string     // For delete_message
+	Chat      string     // Chat where the action happens
+	Channel   *Channel   // Channel reference
+	Raw       map[string]interface{} // Additional data for the action
+}
+
 // Message represents a chat message
 type Message struct {
 	Text    string
@@ -75,7 +95,7 @@ type ChannelPlugin struct {
 	ChannelID int64
 	PluginID  string
 	Enabled   bool
-	Config    map[string]interface{}
+	Config    map[string]any
 }
 
 // User represents an admin user
diff --git a/internal/model/platform.go b/internal/model/platform.go
index 01318eb..7d49ad3 100644
--- a/internal/model/platform.go
+++ b/internal/model/platform.go
@@ -43,4 +43,7 @@ type Platform interface {
 
 	// SendMessage sends a message through the platform
 	SendMessage(msg *Message) error
+
+	// DeleteMessage deletes a message from the platform
+	DeleteMessage(channel string, messageID string) error
 }
diff --git a/internal/model/plugin.go b/internal/model/plugin.go
index 9f2b34a..03e4f96 100644
--- a/internal/model/plugin.go
+++ b/internal/model/plugin.go
@@ -23,6 +23,6 @@ type Plugin interface {
 	// RequiresConfig indicates if the plugin requires configuration
 	RequiresConfig() bool
 
-	// OnMessage processes an incoming message and returns response messages
-	OnMessage(msg *Message, config map[string]interface{}) []*Message
+	// OnMessage processes an incoming message and returns platform actions
+	OnMessage(msg *Message, config map[string]interface{}) []*MessageAction
 }
diff --git a/internal/platform/slack/slack.go b/internal/platform/slack/slack.go
index 9c12b1f..28e8363 100644
--- a/internal/platform/slack/slack.go
+++ b/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
diff --git a/internal/platform/telegram/telegram.go b/internal/platform/telegram/telegram.go
index 0edb729..8da4995 100644
--- a/internal/platform/telegram/telegram.go
+++ b/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)
+}
diff --git a/internal/plugin/domainblock/domainblock.go b/internal/plugin/domainblock/domainblock.go
new file mode 100644
index 0000000..5a44c49
--- /dev/null
+++ b/internal/plugin/domainblock/domainblock.go
@@ -0,0 +1,132 @@
+package domainblock
+
+import (
+	"fmt"
+	"net/url"
+	"regexp"
+	"strings"
+
+	"git.nakama.town/fmartingr/butterrobot/internal/model"
+	"git.nakama.town/fmartingr/butterrobot/internal/plugin"
+)
+
+// DomainBlockPlugin is a plugin that blocks messages containing links from specific domains
+type DomainBlockPlugin struct {
+	plugin.BasePlugin
+}
+
+// Debug helper to check if RequiresConfig is working
+func (p *DomainBlockPlugin) RequiresConfig() bool {
+	return true
+}
+
+// New creates a new DomainBlockPlugin instance
+func New() *DomainBlockPlugin {
+	return &DomainBlockPlugin{
+		BasePlugin: plugin.BasePlugin{
+			ID:             "security.domainblock",
+			Name:           "Domain Blocker",
+			Help:           "Blocks messages containing links from configured domains",
+			ConfigRequired: true,
+		},
+	}
+}
+
+// extractDomains extracts domains from a message text
+func extractDomains(text string) []string {
+	// URL regex pattern
+	urlPattern := regexp.MustCompile(`https?://([^\s/$.?#].[^\s]*)`)
+	matches := urlPattern.FindAllStringSubmatch(text, -1)
+
+	domains := make([]string, 0, len(matches))
+	for _, match := range matches {
+		if len(match) < 2 {
+			continue
+		}
+
+		// Try to parse the URL to extract the domain
+		urlStr := match[0]
+		parsedURL, err := url.Parse(urlStr)
+		if err != nil {
+			continue
+		}
+
+		// Extract the domain (host) from the URL
+		domain := parsedURL.Host
+		// Remove port if present
+		if i := strings.IndexByte(domain, ':'); i >= 0 {
+			domain = domain[:i]
+		}
+
+		domains = append(domains, strings.ToLower(domain))
+	}
+
+	return domains
+}
+
+// OnMessage processes incoming messages
+func (p *DomainBlockPlugin) OnMessage(msg *model.Message, config map[string]interface{}) []*model.MessageAction {
+	// Skip messages from bots
+	if msg.FromBot {
+		return nil
+	}
+
+	// Get blocked domains from config
+	blockedDomainsStr, ok := config["blocked_domains"].(string)
+	if !ok || blockedDomainsStr == "" {
+		return nil // No blocked domains configured
+	}
+
+	// Split and clean blocked domains
+	blockedDomains := strings.Split(blockedDomainsStr, ",")
+	for i, domain := range blockedDomains {
+		blockedDomains[i] = strings.ToLower(strings.TrimSpace(domain))
+	}
+
+	// Extract domains from message
+	messageDomains := extractDomains(msg.Text)
+	if len(messageDomains) == 0 {
+		return nil // No domains in message
+	}
+
+	// Check if any domains in the message are blocked
+	for _, msgDomain := range messageDomains {
+		for _, blockedDomain := range blockedDomains {
+			if blockedDomain == "" {
+				continue
+			}
+
+			if strings.HasSuffix(msgDomain, blockedDomain) || msgDomain == blockedDomain {
+				// Domain is blocked, create actions
+
+				// 1. Create a delete message action
+				deleteAction := &model.MessageAction{
+					Type:      model.ActionDeleteMessage,
+					MessageID: msg.ID,
+					Chat:      msg.Chat,
+					Channel:   msg.Channel,
+				}
+
+				// 2. Create a notification message action
+				notificationMsg := &model.Message{
+					Text:    fmt.Sprintf("I don't like links from %s 🙈", blockedDomain),
+					Chat:    msg.Chat,
+					Channel: msg.Channel,
+				}
+
+				sendAction := &model.MessageAction{
+					Type:    model.ActionSendMessage,
+					Message: notificationMsg,
+					Chat:    msg.Chat,
+					Channel: msg.Channel,
+				}
+
+				return []*model.MessageAction{deleteAction, sendAction}
+			}
+		}
+	}
+
+	return nil
+}
+
+// Plugin is registered in app.go, not using init()
diff --git a/internal/plugin/domainblock/domainblock_test.go b/internal/plugin/domainblock/domainblock_test.go
new file mode 100644
index 0000000..3f75a18
--- /dev/null
+++ b/internal/plugin/domainblock/domainblock_test.go
@@ -0,0 +1,140 @@
+package domainblock
+
+import (
+	"testing"
+
+	"git.nakama.town/fmartingr/butterrobot/internal/model"
+)
+
+func TestExtractDomains(t *testing.T) {
+	tests := []struct {
+		name     string
+		text     string
+		expected []string
+	}{
+		{
+			name:     "No URLs",
+			text:     "Hello, world!",
+			expected: []string{},
+		},
+		{
+			name:     "Single URL",
+			text:     "Check out https://example.com for more info",
+			expected: []string{"example.com"},
+		},
+		{
+			name:     "Multiple URLs",
+			text:     "Check out https://example.com and http://test.example.org for more info",
+			expected: []string{"example.com", "test.example.org"},
+		},
+		{
+			name:     "URL with path",
+			text:     "Check out https://example.com/path/to/resource",
+			expected: []string{"example.com"},
+		},
+		{
+			name:     "URL with port",
+			text:     "Check out https://example.com:8080/path/to/resource",
+			expected: []string{"example.com"},
+		},
+		{
+			name:     "URL with subdomain",
+			text:     "Check out https://sub.example.com",
+			expected: []string{"sub.example.com"},
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			domains := extractDomains(test.text)
+
+			if len(domains) != len(test.expected) {
+				t.Errorf("Expected %d domains, got %d", len(test.expected), len(domains))
+				return
+			}
+
+			for i, domain := range domains {
+				if domain != test.expected[i] {
+					t.Errorf("Expected domain %s, got %s", test.expected[i], domain)
+				}
+			}
+		})
+	}
+}
+
+func TestOnMessage(t *testing.T) {
+	plugin := New()
+
+	tests := []struct {
+		name           string
+		text           string
+		blockedDomains string
+		expectBlocked  bool
+	}{
+		{
+			name:           "No blocked domains",
+			text:           "Check out https://example.com",
+			blockedDomains: "",
+			expectBlocked:  false,
+		},
+		{
+			name:           "No matching domain",
+			text:           "Check out https://example.com",
+			blockedDomains: "bad.com, evil.org",
+			expectBlocked:  false,
+		},
+		{
+			name:           "Matching domain",
+			text:           "Check out https://example.com",
+			blockedDomains: "example.com, evil.org",
+			expectBlocked:  true,
+		},
+		{
+			name:           "Matching subdomain",
+			text:           "Check out https://sub.example.com",
+			blockedDomains: "example.com",
+			expectBlocked:  true,
+		},
+		{
+			name:           "Multiple domains, one matching",
+			text:           "Check out https://example.com and https://good.org",
+			blockedDomains: "bad.com, example.com",
+			expectBlocked:  true,
+		},
+		{
+			name:           "Spaces in blocked domains list",
+			text:           "Check out https://example.com",
+			blockedDomains: "bad.com, example.com , evil.org",
+			expectBlocked:  true,
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			msg := &model.Message{
+				Text: test.text,
+				Chat: "test-chat",
+				ID:   "test-id",
+				Channel: &model.Channel{
+					ID: 1,
+				},
+			}
+
+			config := map[string]interface{}{
+				"blocked_domains": test.blockedDomains,
+			}
+
+			responses := plugin.OnMessage(msg, config)
+
+			if test.expectBlocked {
+				if responses == nil || len(responses) == 0 {
+					t.Errorf("Expected message to be blocked, but it wasn't")
+				}
+			} else {
+				if responses != nil && len(responses) > 0 {
+					t.Errorf("Expected message not to be blocked, but it was")
+				}
+			}
+		})
+	}
+}
\ No newline at end of file
diff --git a/internal/plugin/fun/coin.go b/internal/plugin/fun/coin.go
index 8e12a8d..bd083d1 100644
--- a/internal/plugin/fun/coin.go
+++ b/internal/plugin/fun/coin.go
@@ -29,7 +29,7 @@ func NewCoin() *CoinPlugin {
 }
 
 // OnMessage handles incoming messages
-func (p *CoinPlugin) OnMessage(msg *model.Message, config map[string]interface{}) []*model.Message {
+func (p *CoinPlugin) OnMessage(msg *model.Message, config map[string]interface{}) []*model.MessageAction {
 	if !strings.Contains(strings.ToLower(msg.Text), "flip a coin") {
 		return nil
 	}
@@ -46,5 +46,12 @@ func (p *CoinPlugin) OnMessage(msg *model.Message, config map[string]interface{}
 		Channel: msg.Channel,
 	}
 
-	return []*model.Message{response}
+	action := &model.MessageAction{
+		Type:    model.ActionSendMessage,
+		Message: response,
+		Chat:    msg.Chat,
+		Channel: msg.Channel,
+	}
+
+	return []*model.MessageAction{action}
 }
diff --git a/internal/plugin/fun/dice.go b/internal/plugin/fun/dice.go
index 2d5533b..8b13edb 100644
--- a/internal/plugin/fun/dice.go
+++ b/internal/plugin/fun/dice.go
@@ -32,7 +32,7 @@ func NewDice() *DicePlugin {
 }
 
 // OnMessage handles incoming messages
-func (p *DicePlugin) OnMessage(msg *model.Message, config map[string]interface{}) []*model.Message {
+func (p *DicePlugin) OnMessage(msg *model.Message, config map[string]interface{}) []*model.MessageAction {
 	if !strings.HasPrefix(strings.TrimSpace(strings.ToLower(msg.Text)), "!dice") {
 		return nil
 	}
@@ -62,7 +62,14 @@ func (p *DicePlugin) OnMessage(msg *model.Message, config map[string]interface{}
 		Channel: msg.Channel,
 	}
 
-	return []*model.Message{response}
+	action := &model.MessageAction{
+		Type:    model.ActionSendMessage,
+		Message: response,
+		Chat:    msg.Chat,
+		Channel: msg.Channel,
+	}
+
+	return []*model.MessageAction{action}
 }
 
 // rollDice parses a dice formula string and returns the result
diff --git a/internal/plugin/fun/loquito.go b/internal/plugin/fun/loquito.go
index 7b0ea43..fef78bd 100644
--- a/internal/plugin/fun/loquito.go
+++ b/internal/plugin/fun/loquito.go
@@ -24,7 +24,7 @@ func NewLoquito() *LoquitoPlugin {
 }
 
 // OnMessage handles incoming messages
-func (p *LoquitoPlugin) OnMessage(msg *model.Message, config map[string]interface{}) []*model.Message {
+func (p *LoquitoPlugin) OnMessage(msg *model.Message, config map[string]interface{}) []*model.MessageAction {
 	if !strings.Contains(strings.ToLower(msg.Text), "lo quito") {
 		return nil
 	}
@@ -36,5 +36,12 @@ func (p *LoquitoPlugin) OnMessage(msg *model.Message, config map[string]interfac
 		Channel: msg.Channel,
 	}
 
-	return []*model.Message{response}
+	action := &model.MessageAction{
+		Type:    model.ActionSendMessage,
+		Message: response,
+		Chat:    msg.Chat,
+		Channel: msg.Channel,
+	}
+
+	return []*model.MessageAction{action}
 }
diff --git a/internal/plugin/ping/ping.go b/internal/plugin/ping/ping.go
index b09caaf..e77cb78 100644
--- a/internal/plugin/ping/ping.go
+++ b/internal/plugin/ping/ping.go
@@ -24,17 +24,26 @@ func New() *PingPlugin {
 }
 
 // OnMessage handles incoming messages
-func (p *PingPlugin) OnMessage(msg *model.Message, config map[string]interface{}) []*model.Message {
+func (p *PingPlugin) OnMessage(msg *model.Message, config map[string]interface{}) []*model.MessageAction {
 	if !strings.EqualFold(strings.TrimSpace(msg.Text), "ping") {
 		return nil
 	}
 
+	// Create the response message
 	response := &model.Message{
 		Text:    "pong",
 		Chat:    msg.Chat,
 		ReplyTo: msg.ID,
 		Channel: msg.Channel,
 	}
+	
+	// Create an action to send the message
+	action := &model.MessageAction{
+		Type:    model.ActionSendMessage,
+		Message: response,
+		Chat:    msg.Chat,
+		Channel: msg.Channel,
+	}
 
-	return []*model.Message{response}
+	return []*model.MessageAction{action}
 }
diff --git a/internal/plugin/plugin.go b/internal/plugin/plugin.go
index 69da2c2..eb3789f 100644
--- a/internal/plugin/plugin.go
+++ b/internal/plugin/plugin.go
@@ -1,6 +1,7 @@
 package plugin
 
 import (
+	"maps"
 	"sync"
 
 	"git.nakama.town/fmartingr/butterrobot/internal/model"
@@ -41,9 +42,7 @@ func GetAvailablePlugins() map[string]model.Plugin {
 
 	// Create a copy to avoid race conditions
 	result := make(map[string]model.Plugin, len(plugins))
-	for id, plugin := range plugins {
-		result[id] = plugin
-	}
+	maps.Copy(result, plugins)
 
 	return result
 }
@@ -77,6 +76,6 @@ func (p *BasePlugin) RequiresConfig() bool {
 }
 
 // OnMessage is the default implementation that does nothing
-func (p *BasePlugin) OnMessage(msg *model.Message, config map[string]interface{}) []*model.Message {
+func (p *BasePlugin) OnMessage(msg *model.Message, config map[string]interface{}) []*model.MessageAction {
 	return nil
 }
diff --git a/internal/plugin/reminder/reminder.go b/internal/plugin/reminder/reminder.go
index 5eb47f9..c162e6e 100644
--- a/internal/plugin/reminder/reminder.go
+++ b/internal/plugin/reminder/reminder.go
@@ -41,7 +41,7 @@ func New(creator ReminderCreator) *Reminder {
 }
 
 // OnMessage processes incoming messages
-func (r *Reminder) OnMessage(msg *model.Message, config map[string]interface{}) []*model.Message {
+func (r *Reminder) OnMessage(msg *model.Message, config map[string]interface{}) []*model.MessageAction {
 	// Only process replies to messages
 	if msg.ReplyTo == "" {
 		return nil
@@ -56,15 +56,22 @@ func (r *Reminder) OnMessage(msg *model.Message, config map[string]interface{})
 	// Parse the duration
 	amount, err := strconv.Atoi(match[1])
 	if err != nil {
-		return []*model.Message{
+		errorMsg := &model.Message{
+			Text:    "Invalid duration format. Please use a number followed by y (years), mo (months), d (days), h (hours), m (minutes), or s (seconds).",
+			Chat:    msg.Chat,
+			Channel: msg.Channel,
+			Author:  "bot",
+			FromBot: true,
+			Date:    time.Now(),
+			ReplyTo: msg.ID,
+		}
+		
+		return []*model.MessageAction{
 			{
-				Text:    "Invalid duration format. Please use a number followed by y (years), mo (months), d (days), h (hours), m (minutes), or s (seconds).",
+				Type:    model.ActionSendMessage,
+				Message: errorMsg,
 				Chat:    msg.Chat,
 				Channel: msg.Channel,
-				Author:  "bot",
-				FromBot: true,
-				Date:    time.Now(),
-				ReplyTo: msg.ID,
 			},
 		}
 	}
@@ -86,15 +93,22 @@ func (r *Reminder) OnMessage(msg *model.Message, config map[string]interface{})
 	case "s":
 		duration = time.Duration(amount) * time.Second
 	default:
-		return []*model.Message{
+		errorMsg := &model.Message{
+			Text:    "Invalid duration unit. Please use y (years), mo (months), d (days), h (hours), m (minutes), or s (seconds).",
+			Chat:    msg.Chat,
+			Channel: msg.Channel,
+			Author:  "bot",
+			FromBot: true,
+			Date:    time.Now(),
+			ReplyTo: msg.ID,
+		}
+		
+		return []*model.MessageAction{
 			{
-				Text:    "Invalid duration unit. Please use y (years), mo (months), d (days), h (hours), m (minutes), or s (seconds).",
+				Type:    model.ActionSendMessage,
+				Message: errorMsg,
 				Chat:    msg.Chat,
 				Channel: msg.Channel,
-				Author:  "bot",
-				FromBot: true,
-				Date:    time.Now(),
-				ReplyTo: msg.ID,
 			},
 		}
 	}
@@ -127,15 +141,22 @@ func (r *Reminder) OnMessage(msg *model.Message, config map[string]interface{})
 	)
 
 	if err != nil {
-		return []*model.Message{
+		errorMsg := &model.Message{
+			Text:    fmt.Sprintf("Failed to create reminder: %v", err),
+			Chat:    msg.Chat,
+			Channel: msg.Channel,
+			Author:  "bot",
+			FromBot: true,
+			Date:    time.Now(),
+			ReplyTo: msg.ID,
+		}
+		
+		return []*model.MessageAction{
 			{
-				Text:    fmt.Sprintf("Failed to create reminder: %v", err),
+				Type:    model.ActionSendMessage,
+				Message: errorMsg,
 				Chat:    msg.Chat,
 				Channel: msg.Channel,
-				Author:  "bot",
-				FromBot: true,
-				Date:    time.Now(),
-				ReplyTo: msg.ID,
 			},
 		}
 	}
@@ -157,15 +178,23 @@ func (r *Reminder) OnMessage(msg *model.Message, config map[string]interface{})
 		confirmText = fmt.Sprintf("I'll remind you about this message in %d second(s)", amount)
 	}
 
-	return []*model.Message{
+	// Create confirmation message
+	confirmMsg := &model.Message{
+		Text:    confirmText,
+		Chat:    msg.Chat,
+		Channel: msg.Channel,
+		Author:  "bot",
+		FromBot: true,
+		Date:    time.Now(),
+		ReplyTo: msg.ID,
+	}
+	
+	return []*model.MessageAction{
 		{
-			Text:    confirmText,
+			Type:    model.ActionSendMessage,
+			Message: confirmMsg,
 			Chat:    msg.Chat,
 			Channel: msg.Channel,
-			Author:  "bot",
-			FromBot: true,
-			Date:    time.Now(),
-			ReplyTo: msg.ID,
 		},
 	}
-}
+}
\ No newline at end of file
diff --git a/internal/plugin/reminder/reminder_test.go b/internal/plugin/reminder/reminder_test.go
index 3070918..b54e281 100644
--- a/internal/plugin/reminder/reminder_test.go
+++ b/internal/plugin/reminder/reminder_test.go
@@ -142,14 +142,25 @@ func TestReminderOnMessage(t *testing.T) {
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			initialCount := len(creator.reminders)
-			responses := plugin.OnMessage(tt.message, nil)
+			actions := plugin.OnMessage(tt.message, nil)
 
-			if tt.expectResponse && len(responses) == 0 {
-				t.Errorf("Expected response, but got none")
+			if tt.expectResponse && len(actions) == 0 {
+				t.Errorf("Expected response action, but got none")
 			}
 
-			if !tt.expectResponse && len(responses) > 0 {
-				t.Errorf("Expected no response, but got %d", len(responses))
+			if !tt.expectResponse && len(actions) > 0 {
+				t.Errorf("Expected no actions, but got %d", len(actions))
+			}
+
+			// Verify action type is correct when actions are returned
+			if len(actions) > 0 {
+				if actions[0].Type != model.ActionSendMessage {
+					t.Errorf("Expected action type to be %s, but got %s", model.ActionSendMessage, actions[0].Type)
+				}
+				
+				if actions[0].Message == nil {
+					t.Errorf("Expected message in action to not be nil")
+				}
 			}
 
 			if tt.expectReminder && len(creator.reminders) != initialCount+1 {
diff --git a/internal/plugin/social/instagram.go b/internal/plugin/social/instagram.go
index 7ff74a5..d05bd30 100644
--- a/internal/plugin/social/instagram.go
+++ b/internal/plugin/social/instagram.go
@@ -26,7 +26,7 @@ func NewInstagramExpander() *InstagramExpander {
 }
 
 // OnMessage handles incoming messages
-func (p *InstagramExpander) OnMessage(msg *model.Message, config map[string]interface{}) []*model.Message {
+func (p *InstagramExpander) OnMessage(msg *model.Message, config map[string]interface{}) []*model.MessageAction {
 	// Skip empty messages
 	if strings.TrimSpace(msg.Text) == "" {
 		return nil
@@ -70,5 +70,12 @@ func (p *InstagramExpander) OnMessage(msg *model.Message, config map[string]inte
 		Channel: msg.Channel,
 	}
 
-	return []*model.Message{response}
+	action := &model.MessageAction{
+		Type:    model.ActionSendMessage,
+		Message: response,
+		Chat:    msg.Chat,
+		Channel: msg.Channel,
+	}
+
+	return []*model.MessageAction{action}
 }
diff --git a/internal/plugin/social/twitter.go b/internal/plugin/social/twitter.go
index 837b6c9..865f421 100644
--- a/internal/plugin/social/twitter.go
+++ b/internal/plugin/social/twitter.go
@@ -26,7 +26,7 @@ func NewTwitterExpander() *TwitterExpander {
 }
 
 // OnMessage handles incoming messages
-func (p *TwitterExpander) OnMessage(msg *model.Message, config map[string]interface{}) []*model.Message {
+func (p *TwitterExpander) OnMessage(msg *model.Message, config map[string]interface{}) []*model.MessageAction {
 	// Skip empty messages
 	if strings.TrimSpace(msg.Text) == "" {
 		return nil
@@ -75,5 +75,12 @@ func (p *TwitterExpander) OnMessage(msg *model.Message, config map[string]interf
 		Channel: msg.Channel,
 	}
 
-	return []*model.Message{response}
+	action := &model.MessageAction{
+		Type:    model.ActionSendMessage,
+		Message: response,
+		Chat:    msg.Chat,
+		Channel: msg.Channel,
+	}
+
+	return []*model.MessageAction{action}
 }

From fae6f35774e1dfa5c0b788a2636bdeaf7ae4102f Mon Sep 17 00:00:00 2001
From: "Felipe M." <me@fmartingr.com>
Date: Tue, 22 Apr 2025 18:10:24 +0200
Subject: [PATCH 11/11] chore: make format

---
 cmd/butterrobot/main.go                         |  2 +-
 internal/admin/admin.go                         |  2 +-
 internal/app/app.go                             |  6 +++---
 internal/model/message.go                       |  8 ++++----
 internal/platform/slack/slack.go                |  4 ++--
 internal/plugin/domainblock/domainblock_test.go |  2 +-
 internal/plugin/ping/ping.go                    |  2 +-
 internal/plugin/reminder/reminder.go            | 10 +++++-----
 internal/plugin/reminder/reminder_test.go       |  2 +-
 9 files changed, 19 insertions(+), 19 deletions(-)

diff --git a/cmd/butterrobot/main.go b/cmd/butterrobot/main.go
index bf217de..3bc56cb 100644
--- a/cmd/butterrobot/main.go
+++ b/cmd/butterrobot/main.go
@@ -45,4 +45,4 @@ func main() {
 		logger.Error("Application error", "error", err)
 		os.Exit(1)
 	}
-}
\ No newline at end of file
+}
diff --git a/internal/admin/admin.go b/internal/admin/admin.go
index dee4197..2b41820 100644
--- a/internal/admin/admin.go
+++ b/internal/admin/admin.go
@@ -673,7 +673,7 @@ func (a *Admin) handleChannelPluginConfig(w http.ResponseWriter, r *http.Request
 
 		// Create config map from form values
 		config := make(map[string]interface{})
-		
+
 		// Process form values based on plugin type
 		if channelPlugin.PluginID == "security.domainblock" {
 			// Get blocked domains from form
diff --git a/internal/app/app.go b/internal/app/app.go
index bd64b80..4614325 100644
--- a/internal/app/app.go
+++ b/internal/app/app.go
@@ -325,7 +325,7 @@ func (a *App) handleMessage(item queue.Item) {
 				} else {
 					a.logger.Error("Send message action with nil message")
 				}
-				
+
 			case model.ActionDeleteMessage:
 				// Delete a message using direct DeleteMessage call
 				if err := platform.DeleteMessage(action.Chat, action.MessageID); err != nil {
@@ -333,7 +333,7 @@ func (a *App) handleMessage(item queue.Item) {
 				} else {
 					a.logger.Info("Message deleted", "message_id", action.MessageID)
 				}
-				
+
 			default:
 				a.logger.Error("Unknown action type", "type", action.Type)
 			}
@@ -409,4 +409,4 @@ func (a *App) processReminder(reminder *model.Reminder) {
 	if err := a.db.MarkReminderAsProcessed(reminder.ID); err != nil {
 		a.logger.Error("Error marking reminder as processed", "error", err)
 	}
-}
\ No newline at end of file
+}
diff --git a/internal/model/message.go b/internal/model/message.go
index ea3b316..26ec5da 100644
--- a/internal/model/message.go
+++ b/internal/model/message.go
@@ -17,10 +17,10 @@ const (
 // MessageAction represents an action to be performed on the platform
 type MessageAction struct {
 	Type      ActionType
-	Message   *Message   // For send_message
-	MessageID string     // For delete_message
-	Chat      string     // Chat where the action happens
-	Channel   *Channel   // Channel reference
+	Message   *Message               // For send_message
+	MessageID string                 // For delete_message
+	Chat      string                 // Chat where the action happens
+	Channel   *Channel               // Channel reference
 	Raw       map[string]interface{} // Additional data for the action
 }
 
diff --git a/internal/platform/slack/slack.go b/internal/platform/slack/slack.go
index 28e8363..2ca7bef 100644
--- a/internal/platform/slack/slack.go
+++ b/internal/platform/slack/slack.go
@@ -268,10 +268,10 @@ func (s *SlackPlatform) deleteMessage(msg *model.Message) error {
 	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)
 }
 
diff --git a/internal/plugin/domainblock/domainblock_test.go b/internal/plugin/domainblock/domainblock_test.go
index 3f75a18..69cd8b8 100644
--- a/internal/plugin/domainblock/domainblock_test.go
+++ b/internal/plugin/domainblock/domainblock_test.go
@@ -137,4 +137,4 @@ func TestOnMessage(t *testing.T) {
 			}
 		})
 	}
-}
\ No newline at end of file
+}
diff --git a/internal/plugin/ping/ping.go b/internal/plugin/ping/ping.go
index e77cb78..3dacf6f 100644
--- a/internal/plugin/ping/ping.go
+++ b/internal/plugin/ping/ping.go
@@ -36,7 +36,7 @@ func (p *PingPlugin) OnMessage(msg *model.Message, config map[string]interface{}
 		ReplyTo: msg.ID,
 		Channel: msg.Channel,
 	}
-	
+
 	// Create an action to send the message
 	action := &model.MessageAction{
 		Type:    model.ActionSendMessage,
diff --git a/internal/plugin/reminder/reminder.go b/internal/plugin/reminder/reminder.go
index c162e6e..029c8d9 100644
--- a/internal/plugin/reminder/reminder.go
+++ b/internal/plugin/reminder/reminder.go
@@ -65,7 +65,7 @@ func (r *Reminder) OnMessage(msg *model.Message, config map[string]interface{})
 			Date:    time.Now(),
 			ReplyTo: msg.ID,
 		}
-		
+
 		return []*model.MessageAction{
 			{
 				Type:    model.ActionSendMessage,
@@ -102,7 +102,7 @@ func (r *Reminder) OnMessage(msg *model.Message, config map[string]interface{})
 			Date:    time.Now(),
 			ReplyTo: msg.ID,
 		}
-		
+
 		return []*model.MessageAction{
 			{
 				Type:    model.ActionSendMessage,
@@ -150,7 +150,7 @@ func (r *Reminder) OnMessage(msg *model.Message, config map[string]interface{})
 			Date:    time.Now(),
 			ReplyTo: msg.ID,
 		}
-		
+
 		return []*model.MessageAction{
 			{
 				Type:    model.ActionSendMessage,
@@ -188,7 +188,7 @@ func (r *Reminder) OnMessage(msg *model.Message, config map[string]interface{})
 		Date:    time.Now(),
 		ReplyTo: msg.ID,
 	}
-	
+
 	return []*model.MessageAction{
 		{
 			Type:    model.ActionSendMessage,
@@ -197,4 +197,4 @@ func (r *Reminder) OnMessage(msg *model.Message, config map[string]interface{})
 			Channel: msg.Channel,
 		},
 	}
-}
\ No newline at end of file
+}
diff --git a/internal/plugin/reminder/reminder_test.go b/internal/plugin/reminder/reminder_test.go
index b54e281..8e611ce 100644
--- a/internal/plugin/reminder/reminder_test.go
+++ b/internal/plugin/reminder/reminder_test.go
@@ -157,7 +157,7 @@ func TestReminderOnMessage(t *testing.T) {
 				if actions[0].Type != model.ActionSendMessage {
 					t.Errorf("Expected action type to be %s, but got %s", model.ActionSendMessage, actions[0].Type)
 				}
-				
+
 				if actions[0].Message == nil {
 					t.Errorf("Expected message in action to not be nil")
 				}