fix(telegram): send error messages to user when command/callback handlers fail

Previously, when a command or callback query handler returned an error,
the error was logged and OnError was called, but the user received no
response — leaving them staring at silence.

Now SendResponse is called with "❌ " + error text so the user knows
the command failed and gets the error message.

3 new tests: command error, callback error, no double-send on success

Author: molty3000

internal/telegram/handler.go

@@ -278,6 +278,8 @@ func (h *Handler) handleCommand(msg *Message) {
 			if h.OnError != nil {
 				h.OnError(msg.Chat.ID, err)
 			}
+			// Send the error message to the user so they know the command failed.
+			h.SendResponse(msg.Chat.ID, "❌ "+err.Error(), msg.ID)
 			return
 		}
 		if resp != "" {
@@ -320,6 +322,8 @@ func (h *Handler) handleCallback(cq *CallbackQuery) {
 			if h.OnError != nil {
 				h.OnError(cq.Message.Chat.ID, err)
 			}
+			// Send the error message to the user.
+			h.SendResponse(cq.Message.Chat.ID, "❌ "+err.Error(), cq.Message.ID)
 			return
 		}
 		if resp != "" {

internal/telegram/handler_error_test.go

@@ -0,0 +1,132 @@
+package telegram
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+// TestHandleCommand_ErrorSentToUser verifies that when a command handler
+// returns an error, the error message is sent to the user (not just logged).
+func TestHandleCommand_ErrorSentToUser(t *testing.T) {
+	rec := new(requestRecorder)
+	ts := testServer(t, rec)
+	defer ts.Close()
+	bot := testBot(t, ts)
+	h := NewHandler(bot)
+
+	h.OnCommand = func(chatID int64, messageID int, cmd string, args string) (string, error) {
+		return "", fmt.Errorf("simulated command failure: %s", cmd)
+	}
+
+	upd := Update{
+		ID: 1,
+		Message: &Message{
+			ID:   42,
+			Chat: &Chat{ID: 123},
+			From: &User{ID: 456},
+			Text: "/start",
+			Entities: []MessageEntity{
+				{Type: "bot_command", Offset: 0, Length: 6},
+			},
+		},
+	}
+
+	h.HandleUpdate(upd)
+
+	// Verify a sendMessage was sent with the error text.
+	found := false
+	for _, r := range rec.all() {
+		if strings.Contains(r.Path, "sendMessage") {
+			if strings.Contains(r.Body, "simulated command failure") {
+				found = true
+				break
+			}
+		}
+	}
+	if !found {
+		t.Error("error from command handler was not sent to user")
+	}
+}
+
+// TestHandleCallback_ErrorSentToUser verifies that when a callback query
+// handler returns an error, the error message is sent to the user.
+func TestHandleCallback_ErrorSentToUser(t *testing.T) {
+	rec := new(requestRecorder)
+	ts := testServer(t, rec)
+	defer ts.Close()
+	bot := testBot(t, ts)
+	h := NewHandler(bot)
+
+	h.OnCallbackQuery = func(chatID int64, data string) (string, error) {
+		return "", fmt.Errorf("simulated callback failure: %s", data)
+	}
+
+	upd := Update{
+		ID: 2,
+		CallbackQuery: &CallbackQuery{
+			ID:   "cq_test",
+			From: &User{ID: 456},
+			Message: &Message{
+				Chat: &Chat{ID: 789},
+			},
+			Data: "test_data",
+		},
+	}
+
+	h.HandleUpdate(upd)
+
+	// Verify a sendMessage was sent with the error text.
+	found := false
+	for _, r := range rec.all() {
+		if strings.Contains(r.Path, "sendMessage") {
+			if strings.Contains(r.Body, "simulated callback failure") {
+				found = true
+				break
+			}
+		}
+	}
+	if !found {
+		t.Error("error from callback handler was not sent to user")
+	}
+}
+
+// TestHandleCommand_ErrorNotSentOnSuccess verifies that successful commands
+// still send only the response text (not double-sending).
+func TestHandleCommand_ErrorNotSentOnSuccess(t *testing.T) {
+	rec := new(requestRecorder)
+	ts := testServer(t, rec)
+	defer ts.Close()
+	bot := testBot(t, ts)
+	h := NewHandler(bot)
+
+	h.OnCommand = func(chatID int64, messageID int, cmd string, args string) (string, error) {
+		return "ok response", nil
+	}
+
+	upd := Update{
+		ID: 3,
+		Message: &Message{
+			ID:   99,
+			Chat: &Chat{ID: 111},
+			From: &User{ID: 222},
+			Text: "/status",
+			Entities: []MessageEntity{
+				{Type: "bot_command", Offset: 0, Length: 7},
+			},
+		},
+	}
+
+	h.HandleUpdate(upd)
+
+	// Count sendMessage calls — should be exactly 1 (for the response).
+	sendCount := 0
+	for _, r := range rec.all() {
+		if strings.Contains(r.Path, "sendMessage") {
+			sendCount++
+		}
+	}
+	if sendCount != 1 {
+		t.Errorf("expected 1 sendMessage, got %d (should not double-send on success)", sendCount)
+	}
+}