chore: make format

feat: domain blocker plugin
fix: make format
2025-04-22 18:10:24 +02:00 · 2025-04-22 18:09:27 +02:00 · 2025-04-22 11:56:57 +02:00 · 2025-04-22 11:56:33 +02:00 · 2025-04-22 11:41:56 +02:00 · 2025-04-22 11:40:10 +02:00
35 changed files with 1941 additions and 131 deletions
--- 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:
--- a/.woodpecker/ci.yml
+++ b/.woodpecker/ci.yml
@ -3,7 +3,7 @@ when:
    - push
    - pull_request
  branch:
-    - main
+    - master

 steps:
  format:
--- a/.woodpecker/release.yml
+++ b/.woodpecker/release.yml
@ -1,6 +1,6 @@
 when:
  - event: tag
-    branch: main
+    branch: master

 steps:
  - name: Release
--- 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
--- 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() {
--- a/docs/creating-a-plugin.md
+++ b/docs/creating-a-plugin.md
@ -1,6 +1,19 @@
 # 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
+- **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.
+
+## Plugin Examples
+
+### Basic Example: Marco Polo

 This simple "Marco Polo" plugin will answer _Polo_ to the user that says _Marco_:

@ -47,6 +60,207 @@ 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:
+
+```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}
+}
+```
+
+## 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:

 ```go
@ -55,8 +269,19 @@ 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

    // ...
 }
 ```
+
+Alternatively, you can register your plugin in its init() function:
+
+```go
+func init() {
+    plugin.Register(New())
+}
+```
--- a/docs/plugins.md
+++ b/docs/plugins.md
@ -9,3 +9,16 @@
 - 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.
+
+### 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.
+
+### 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.
+- 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.
--- 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
 )

--- 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=
--- 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{
@ -96,6 +98,7 @@ func New(cfg *config.Config, database *db.Database) *Admin {
 		"channel_detail.html",
 		"plugin_list.html",
 		"channel_plugins_list.html",
+		"channel_plugin_config.html",
 	}

 	for _, tf := range templateFiles {
@ -104,19 +107,19 @@ func New(cfg *config.Config, database *db.Database) *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
 	}

@ -126,6 +129,7 @@ func New(cfg *config.Config, database *db.Database) *Admin {
 		store:        store,
 		templates:    templates,
 		baseTemplate: baseTemplate,
+		version:      version,
 	}
 }

@ -140,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)
 }

@ -191,7 +196,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"
@ -246,17 +251,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) {
 	// Add current user data
@ -264,6 +258,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]
@ -330,7 +325,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")

@ -358,7 +356,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)
@ -632,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
--- 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>
--- 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>
--- a/internal/admin/templates/channel_plugin_config.html
+++ 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}}
--- 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}}
+{{end}}
--- 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"
@ -16,21 +17,26 @@ 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/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"
+	"git.nakama.town/fmartingr/butterrobot/internal/plugin/social"
 	"git.nakama.town/fmartingr/butterrobot/internal/queue"
 )

 // 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
@ -47,16 +53,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
 }

@ -72,6 +86,10 @@ 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())
+	plugin.Register(reminder.New(a.db))
+	plugin.Register(domainblock.New())

 	// Initialize routes
 	a.initializeRoutes()
@ -79,6 +97,9 @@ func (a *App) Run() error {
 	// 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{
@ -130,7 +151,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
@ -153,7 +176,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
 	}

@ -162,7 +187,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
 	}

@ -178,7 +205,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
@ -274,20 +303,110 @@ 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)
 			}
 		}
 	}
 }
+
+// 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)
+	}
+}
--- 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"
@ -233,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

@ -381,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 := `
@ -414,7 +437,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

@ -453,10 +480,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)
@ -591,6 +617,124 @@ 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 func() {
+		if err := rows.Close(); err != nil {
+			fmt.Printf("Error closing rows: %v\n", err)
+		}
+	}()
+
+	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 +753,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 +779,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 +790,6 @@ func initDatabase(db *sql.DB) error {
 	} else {
 		fmt.Println("Database schema is up to date.")
 	}
-	
+
 	return nil
 }
--- 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
-}
+}
--- 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
-}
+}
+
+// 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
+}
--- a/internal/model/message.go
+++ b/internal/model/message.go
@ -4,27 +4,47 @@ 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
-	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 +60,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 +85,7 @@ func (c *Channel) ChannelName() string {
 			return firstName
 		}
 	}
-	
+
 	return c.PlatformChannelID
 }

@ -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
@ -83,4 +103,19 @@ type User struct {
 	ID       int64
 	Username string
 	Password string
-}
+}
+
+// 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
+}
--- 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
 }
--- 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
-}
+
+	// OnMessage processes an incoming message and returns platform actions
+	OnMessage(msg *Message, config map[string]interface{}) []*MessageAction
+}
--- 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{}
@ -163,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,
@ -194,7 +204,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 {
@ -204,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
--- 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 {
@ -103,8 +111,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 +139,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,
 	}

@ -205,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 {
@ -247,7 +266,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 {
@ -259,4 +282,89 @@ 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)
+}
--- a/internal/plugin/domainblock/domainblock.go
+++ 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()
--- a/internal/plugin/domainblock/domainblock_test.go
+++ 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")
+				}
+			}
+		})
+	}
+}
--- 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}
 }
--- 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
@ -107,9 +114,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
 		}
 	}
--- 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}
 }
--- a/internal/plugin/ping/ping.go
+++ b/internal/plugin/ping/ping.go
@ -24,11 +24,12 @@ 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,
@ -36,5 +37,13 @@ func (p *PingPlugin) OnMessage(msg *model.Message, config map[string]interface{}
 		Channel: msg.Channel,
 	}

-	return []*model.Message{response}
+	// Create an action to send the message
+	action := &model.MessageAction{
+		Type:    model.ActionSendMessage,
+		Message: response,
+		Chat:    msg.Chat,
+		Channel: msg.Channel,
+	}
+
+	return []*model.MessageAction{action}
 }
--- 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
 }
--- a/internal/plugin/reminder/reminder.go
+++ b/internal/plugin/reminder/reminder.go
@ -0,0 +1,200 @@
+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.MessageAction {
+	// Only process replies to messages
+	if msg.ReplyTo == "" {
+		return nil
+	}
+
+	// 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 {
+		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{
+			{
+				Type:    model.ActionSendMessage,
+				Message: errorMsg,
+				Chat:    msg.Chat,
+				Channel: msg.Channel,
+			},
+		}
+	}
+
+	// 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:
+		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{
+			{
+				Type:    model.ActionSendMessage,
+				Message: errorMsg,
+				Chat:    msg.Chat,
+				Channel: msg.Channel,
+			},
+		}
+	}
+
+	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 {
+		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{
+			{
+				Type:    model.ActionSendMessage,
+				Message: errorMsg,
+				Chat:    msg.Chat,
+				Channel: msg.Channel,
+			},
+		}
+	}
+
+	// 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)
+	}
+
+	// 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{
+		{
+			Type:    model.ActionSendMessage,
+			Message: confirmMsg,
+			Chat:    msg.Chat,
+			Channel: msg.Channel,
+		},
+	}
+}
--- a/internal/plugin/reminder/reminder_test.go
+++ b/internal/plugin/reminder/reminder_test.go
@ -0,0 +1,175 @@
+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)
+			actions := plugin.OnMessage(tt.message, nil)
+
+			if tt.expectResponse && len(actions) == 0 {
+				t.Errorf("Expected response action, but got none")
+			}
+
+			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 {
+				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)
+			}
+		})
+	}
+}
--- a/internal/plugin/social/instagram.go
+++ b/internal/plugin/social/instagram.go
@ -0,0 +1,81 @@
+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.MessageAction {
+	// 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
+		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,
+	}
+
+	action := &model.MessageAction{
+		Type:    model.ActionSendMessage,
+		Message: response,
+		Chat:    msg.Chat,
+		Channel: msg.Channel,
+	}
+
+	return []*model.MessageAction{action}
+}
--- a/internal/plugin/social/twitter.go
+++ b/internal/plugin/social/twitter.go
@ -0,0 +1,86 @@
+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.MessageAction {
+	// 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,
+	}
+
+	action := &model.MessageAction{
+		Type:    model.ActionSendMessage,
+		Message: response,
+		Chat:    msg.Chat,
+		Channel: msg.Channel,
+	}
+
+	return []*model.MessageAction{action}
+}
--- 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
 		}
 	}
-}
+}
+
+// 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
+		}
+	}
+}
Author	SHA1	Message	Date
Felipe M.	fae6f35774	chore: make format Some checks failed ci/woodpecker/push/ci Pipeline failed Details	2025-04-22 18:10:24 +02:00
Felipe M.	7dd02c0056	feat: domain blocker plugin Some checks failed ci/woodpecker/tag/release Pipeline was successful Details ci/woodpecker/push/ci Pipeline failed Details	2025-04-22 18:09:27 +02:00
Felipe M.	c9edb57505	fix: make format All checks were successful ci/woodpecker/push/ci Pipeline was successful Details	2025-04-22 11:56:57 +02:00
Felipe M.	763a451251	fix: lint errors	2025-04-22 11:56:33 +02:00
Felipe M.	abcd3c3c44	docs: updated README	2025-04-22 11:41:56 +02:00
Felipe M.	323ea4e8cd	fix(ci): updated woodpecker triggers Some checks failed ci/woodpecker/push/ci Pipeline failed Details	2025-04-22 11:40:10 +02:00
Felipe M.	72c6dd6982	feat: remindme plugin All checks were successful ci/woodpecker/tag/release Pipeline was successful Details	2025-04-22 11:29:39 +02:00
Felipe M.	21e4c434fd	docs: updated plugin docs All checks were successful ci/woodpecker/tag/release Pipeline was successful Details	2025-04-21 18:10:30 +02:00
Felipe M.	a0f12efd65	feat: show version in admin page	2025-04-21 18:08:40 +02:00
Felipe M.	c920eb94a0	feat: added twitter and instagram link expanders All checks were successful ci/woodpecker/tag/release Pipeline was successful Details	2025-04-21 18:03:07 +02:00
Felipe M.	e0ae0c2a0b	fix: missing ca-certs All checks were successful ci/woodpecker/tag/release Pipeline was successful Details	2025-04-21 17:12:29 +02:00