P9(5): restore upstream Telegram bot (settings, backup, notifications)

Per user decision 2026-10-21 (reverses the 2026-10-20 drop-Telegram
call): port the upstream 3x-ui v3.7.0-generation Telegram bot wholesale
instead of rewriting a minimal set, adapted to this fork.

- new internal/web/service/tgbot package (telego): bot lifecycle,
  commands, reports, callback router, send helpers; token validation via
  telego; custom API server URL passes the fork's SSRF sanitizer
  (loopback/private bases fall back to the default endpoint, logged)
- settings: full upstream key set (tgBotEnable/Token/Proxy/APIServer/
  ChatId, tgRunTime, tgBotBackup, tgCpu/tgMemory, tgLang,
  tgEnabledEvents) with getters/setters; settings page gains a Telegram
  tab + sidebar entry; token shown masked, clearTgBotToken honored
- wiring (web.go): stats-notify cron registered from tgRunTime when the
  bot is enabled; CheckHashStorage job; CPU/memory alarm jobs gated on
  tgEnabledEvents + thresholds; login notifications via event bus;
  POST /panel/api/setting/testTgBot and /panel/api/backuptotgbot
- lite adaptation: StatsNotifyJob no longer gates on a local Xray core
  (this panel never runs one) so the periodic report and the scheduled
  DB backup (sendDocument) can actually fire
- translations: upstream TG keys restored across all locales

End-to-end smoke (real binary + fake Telegram API over HTTPS at a
public-looking address, browser form wire format): bot starts on
settings change (getMe), testTgBot delivers, panel restart re-arms the
bot, tgRunTime='@every 1m' cron really fires sendDocument carrying the
panel SQLite DB (magic verified) plus the report sendMessage, login
notification delivered, dead-endpoint failure is logged not silent.
13/13 PASS — see P9-REPORT.md.

internal/web/service/inbound_tgbot_lookup_test.go

@@ -0,0 +1,67 @@
+package service
+
+import (
+	"path/filepath"
+	"testing"
+
+	"github.com/mhsanaei/3x-ui/v3/internal/database"
+	"github.com/mhsanaei/3x-ui/v3/internal/database/model"
+	"github.com/mhsanaei/3x-ui/v3/internal/xray"
+)
+
+// TestGetClientTrafficTgBot_SettingsSerializationStyles guards against the
+// prefilter regressing into a formatting-sensitive string match (#5805): the
+// lookup must find clients whether inbounds.settings stores compact JSON
+// ("tgId":N, as written by node sync/import) or indented JSON ("tgId": N, as
+// written by the panel's MarshalIndent).
+func TestGetClientTrafficTgBot_SettingsSerializationStyles(t *testing.T) {
+	dbDir := t.TempDir()
+	t.Setenv("XUI_DB_FOLDER", dbDir)
+	if err := database.InitDB(filepath.Join(dbDir, "x-ui.db")); err != nil {
+		t.Fatalf("InitDB: %v", err)
+	}
+	t.Cleanup(func() { _ = database.CloseDB() })
+
+	db := database.GetDB()
+
+	const tgId int64 = 123456789
+	cases := []struct {
+		name     string
+		settings string
+		email    string
+		port     int
+	}{
+		{"compact", `{"clients":[{"id":"u1","email":"compact-user","tgId":123456789}]}`, "compact-user", 41001},
+		{"spaced", `{"clients": [{"id": "u2", "email": "spaced-user", "tgId": 123456789}]}`, "spaced-user", 41002},
+	}
+	for _, c := range cases {
+		inbound := &model.Inbound{UserId: 1, Tag: "tg-" + c.name, Enable: true, Port: c.port, Protocol: model.VLESS, Settings: c.settings}
+		if err := db.Create(inbound).Error; err != nil {
+			t.Fatalf("create %s inbound: %v", c.name, err)
+		}
+		if err := db.Create(&xray.ClientTraffic{InboundId: inbound.Id, Email: c.email, Enable: true, Up: 10, Down: 20}).Error; err != nil {
+			t.Fatalf("create %s client_traffics: %v", c.name, err)
+		}
+	}
+
+	svc := InboundService{}
+	traffics, err := svc.GetClientTrafficTgBot(tgId)
+	if err != nil {
+		t.Fatalf("GetClientTrafficTgBot: %v", err)
+	}
+	got := make(map[string]bool, len(traffics))
+	for _, tr := range traffics {
+		got[tr.Email] = true
+	}
+	if len(traffics) != 2 || !got["compact-user"] || !got["spaced-user"] {
+		t.Fatalf("expected traffic for compact-user and spaced-user, got %v", got)
+	}
+
+	other, err := svc.GetClientTrafficTgBot(42)
+	if err != nil {
+		t.Fatalf("GetClientTrafficTgBot(42): %v", err)
+	}
+	if len(other) != 0 {
+		t.Fatalf("expected no traffic for unknown tgId, got %d rows", len(other))
+	}
+}

internal/web/service/inbound_traffic.go

@@ -7,6 +7,7 @@ import (
 	"fmt"
 	"maps"
 	"slices"
+	"strconv"
 	"strings"
 	"time"
 
@@ -1179,3 +1180,71 @@ func (s *InboundService) SearchClientTraffic(query string) (traffic *xray.Client
 
 	return traffic, nil
 }
+func (s *InboundService) GetClientTrafficTgBot(tgId int64) ([]*xray.ClientTraffic, error) {
+	db := database.GetDB()
+
+	idQuery := fmt.Sprintf(
+		"SELECT DISTINCT inbounds.id %s WHERE %s = ?",
+		database.JSONClientsFromInbound(),
+		database.JSONFieldText("client.value", "tgId"),
+	)
+	var inboundIds []int
+	if err := db.Raw(idQuery, strconv.FormatInt(tgId, 10)).Scan(&inboundIds).Error; err != nil {
+		logger.Errorf("Error retrieving inbounds with tgId %d: %v", tgId, err)
+		return nil, err
+	}
+
+	var inbounds []*model.Inbound
+	if len(inboundIds) > 0 {
+		err := db.Model(model.Inbound{}).Where("id IN ?", inboundIds).Find(&inbounds).Error
+		if err != nil && !errors.Is(err, gorm.ErrRecordNotFound) {
+			logger.Errorf("Error retrieving inbounds with tgId %d: %v", tgId, err)
+			return nil, err
+		}
+	}
+
+	var emails []string
+	for _, inbound := range inbounds {
+		clients, err := s.GetClients(inbound)
+		if err != nil {
+			logger.Errorf("Error retrieving clients for inbound %d: %v", inbound.Id, err)
+			continue
+		}
+		for _, client := range clients {
+			if client.TgID == tgId {
+				emails = append(emails, client.Email)
+			}
+		}
+	}
+
+	// Chunked to stay under SQLite's bind-variable limit when a single Telegram
+	// account owns thousands of clients across inbounds.
+	uniqEmails := uniqueNonEmptyStrings(emails)
+	traffics := make([]*xray.ClientTraffic, 0, len(uniqEmails))
+	for _, batch := range chunkStrings(uniqEmails, sqliteMaxVars) {
+		var page []*xray.ClientTraffic
+		if err := db.Model(xray.ClientTraffic{}).Where("email IN ?", batch).Find(&page).Error; err != nil {
+			if errors.Is(err, gorm.ErrRecordNotFound) {
+				continue
+			}
+			logger.Errorf("Error retrieving ClientTraffic for emails %v: %v", batch, err)
+			return nil, err
+		}
+		traffics = append(traffics, page...)
+	}
+	if len(traffics) == 0 {
+		logger.Warning("No ClientTraffic records found for emails:", emails)
+		return nil, nil
+	}
+
+	// Populate UUID and other client data for each traffic record
+	for i := range traffics {
+		if ct, client, e := s.GetClientByEmail(traffics[i].Email); e == nil && ct != nil && client != nil {
+			traffics[i].Enable = client.Enable
+			traffics[i].UUID = client.ID
+			traffics[i].SubId = client.SubID
+		}
+	}
+
+	return traffics, nil
+}

internal/web/service/setting.go

@@ -112,6 +112,19 @@ var defaultValueMap = map[string]string{
 	// Event bus — per-subscriber event filtering (empty = all disabled)
 
 	// Consecutive failed observatory probes before an outbound.down event fires
+	"tgBotEnable":    "false",
+	"tgBotToken":     "",
+	"tgBotProxy":     "",
+	"tgBotAPIServer": "",
+	"tgBotChatId":    "",
+	"tgRunTime":      "@daily",
+	"tgBotBackup":    "false",
+	"tgCpu":          "80",
+	"tgMemory":       "80",
+	"tgLang":         "en-US",
+	// Event bus — per-subscriber event filtering (empty = all disabled)
+	"tgEnabledEvents": "login.attempt,cpu.high",
+
 	"outboundDownThreshold": "3",
 }
 
@@ -209,6 +222,8 @@ func (s *SettingService) GetAllSettingView() (*entity.AllSettingView, error) {
 		return nil, err
 	}
 	view := &entity.AllSettingView{AllSetting: *allSetting}
+	view.HasTgBotToken = secretConfigured(allSetting.TgBotToken)
+	view.TgBotToken = ""
 	view.HasWarpSecret = secretConfigured(mustString(s.GetWarp()))
 	view.HasNordSecret = secretConfigured(mustString(s.GetNord()))
 	var apiTokenCount int64
@@ -761,6 +776,83 @@ func (s *SettingService) GetAccessLogEnable() (bool, error) {
 // GetOutboundDownThreshold returns how many consecutive failed observatory
 // probes an outbound must accumulate before an outbound.down notification is
 // emitted. 1 preserves the legacy "notify on the first failed probe" behaviour.
+
+func (s *SettingService) GetTgBotToken() (string, error) {
+	return s.getString("tgBotToken")
+}
+
+func (s *SettingService) SetTgBotToken(token string) error {
+	return s.setString("tgBotToken", token)
+}
+
+func (s *SettingService) GetTgBotProxy() (string, error) {
+	return s.getString("tgBotProxy")
+}
+
+func (s *SettingService) SetTgBotProxy(token string) error {
+	return s.setString("tgBotProxy", token)
+}
+
+func (s *SettingService) GetTgBotAPIServer() (string, error) {
+	return s.getString("tgBotAPIServer")
+}
+
+func (s *SettingService) SetTgBotAPIServer(token string) error {
+	return s.setString("tgBotAPIServer", token)
+}
+
+func (s *SettingService) GetTgBotChatId() (string, error) {
+	return s.getString("tgBotChatId")
+}
+
+func (s *SettingService) SetTgBotChatId(chatIds string) error {
+	return s.setString("tgBotChatId", chatIds)
+}
+
+func (s *SettingService) GetTgbotEnabled() (bool, error) {
+	return s.getBool("tgBotEnable")
+}
+
+func (s *SettingService) SetTgbotEnabled(value bool) error {
+	return s.setBool("tgBotEnable", value)
+}
+
+func (s *SettingService) GetTgbotRuntime() (string, error) {
+	return s.getString("tgRunTime")
+}
+
+func (s *SettingService) SetTgbotRuntime(time string) error {
+	return s.setString("tgRunTime", time)
+}
+
+func (s *SettingService) GetTgBotBackup() (bool, error) {
+	return s.getBool("tgBotBackup")
+}
+
+func (s *SettingService) GetTgCpu() (int, error) {
+	return s.getInt("tgCpu")
+}
+
+func (s *SettingService) GetTgMemory() (int, error) {
+	return s.getInt("tgMemory")
+}
+
+func (s *SettingService) SetTgMemory(value int) error {
+	return s.setInt("tgMemory", value)
+}
+
+func (s *SettingService) GetTgLang() (string, error) {
+	return s.getString("tgLang")
+}
+
+func (s *SettingService) GetTgEnabledEvents() (string, error) {
+	return s.getString("tgEnabledEvents")
+}
+
+func (s *SettingService) SetTgEnabledEvents(events string) error {
+	return s.setString("tgEnabledEvents", events)
+}
+
 func (s *SettingService) GetOutboundDownThreshold() (int, error) {
 	return s.getInt("outboundDownThreshold")
 }
@@ -769,7 +861,17 @@ func (s *SettingService) SetOutboundDownThreshold(value int) error {
 	return s.setInt("outboundDownThreshold", value)
 }
 
-func (s *SettingService) UpdateAllSetting(allSetting *entity.AllSetting) error {
+// SecretClears marks redacted secrets the user explicitly emptied. Without a
+// flag, a blank submitted secret means "unchanged" (the field is always served
+// blank to the browser) and the stored value is preserved.
+type SecretClears struct {
+	TgBotToken bool
+}
+
+func (s *SettingService) UpdateAllSetting(allSetting *entity.AllSetting, clears SecretClears) error {
+	if err := s.preserveRedactedSecrets(allSetting, clears); err != nil {
+		return err
+	}
 	if err := validateSettingsURLs(allSetting); err != nil {
 		return err
 	}
@@ -858,7 +960,25 @@ func ValidateRegex(pattern string) error {
 	return nil
 }
 
+func (s *SettingService) preserveRedactedSecrets(allSetting *entity.AllSetting, clears SecretClears) error {
+	if !clears.TgBotToken && strings.TrimSpace(allSetting.TgBotToken) == "" {
+		value, err := s.GetTgBotToken()
+		if err != nil {
+			return err
+		}
+		allSetting.TgBotToken = value
+	}
+	return nil
+}
+
 func validateSettingsURLs(allSetting *entity.AllSetting) error {
+	if allSetting.TgBotAPIServer != "" {
+		u, err := SanitizeHTTPURL(allSetting.TgBotAPIServer)
+		if err != nil {
+			return common.NewError("telegram API server URL is invalid:", err)
+		}
+		allSetting.TgBotAPIServer = u
+	}
 	// Support/profile links land in subscription headers and page data, where
 	// client apps resolve a scheme-less value against the panel's own domain.
 	// Non-http schemes (tg://, mailto:) are legitimate here, so only default

internal/web/service/setting_clash_test.go

@@ -79,7 +79,7 @@ func TestUpdateAllSettingPreservesEmptyUserAgentRegexes(t *testing.T) {
 	settings.SubJsonUserAgentRegex = "   "
 	settings.SubClashUserAgentRegex = ""
 
-	if err := s.UpdateAllSetting(settings); err != nil {
+	if err := s.UpdateAllSetting(settings, SecretClears{}); err != nil {
 		t.Fatal(err)
 	}
 
@@ -129,7 +129,7 @@ func TestUpdateAllSettingPersistsClashSubscriptionSettings(t *testing.T) {
 	settings.SubClashPath = "/clash-custom/"
 	settings.SubClashURI = "https://subscriptions.example.com/clash-custom/"
 
-	if err := s.UpdateAllSetting(settings); err != nil {
+	if err := s.UpdateAllSetting(settings, SecretClears{}); err != nil {
 		t.Fatal(err)
 	}
 
@@ -180,7 +180,7 @@ func TestUpdateAllSettingRejectsInvalidClashUserAgentRegex(t *testing.T) {
 		t.Fatal(err)
 	}
 	settings.SubClashUserAgentRegex = "["
-	if err := s.UpdateAllSetting(settings); err == nil {
+	if err := s.UpdateAllSetting(settings, SecretClears{}); err == nil {
 		t.Fatal("UpdateAllSetting accepted an invalid Clash/Mihomo User-Agent regex")
 	}
 }
@@ -193,7 +193,7 @@ func TestUpdateAllSettingRejectsInvalidJsonUserAgentRegex(t *testing.T) {
 		t.Fatal(err)
 	}
 	settings.SubJsonUserAgentRegex = "["
-	if err := s.UpdateAllSetting(settings); err == nil {
+	if err := s.UpdateAllSetting(settings, SecretClears{}); err == nil {
 		t.Fatal("UpdateAllSetting accepted an invalid Xray JSON User-Agent regex")
 	}
 }

internal/web/service/setting_sub_identity_test.go

@@ -18,7 +18,7 @@ func TestSubShowIdentityOnAllLinksDefaultsAndPersists(t *testing.T) {
 	}
 
 	settings.SubShowIdentityOnAllLinks = true
-	if err := s.UpdateAllSetting(settings); err != nil {
+	if err := s.UpdateAllSetting(settings, SecretClears{}); err != nil {
 		t.Fatal(err)
 	}
 	if got, err := s.GetSubShowIdentityOnAllLinks(); err != nil || !got {
@@ -30,7 +30,7 @@ func TestSubShowIdentityOnAllLinksDefaultsAndPersists(t *testing.T) {
 		t.Fatal(err)
 	}
 	settings.SubShowIdentityOnAllLinks = false
-	if err := s.UpdateAllSetting(settings); err != nil {
+	if err := s.UpdateAllSetting(settings, SecretClears{}); err != nil {
 		t.Fatal(err)
 	}
 	if got, err := s.GetSubShowIdentityOnAllLinks(); err != nil || got {

internal/web/service/tgbot/numeric_input.go

@@ -0,0 +1,17 @@
+package tgbot
+
+// updateNumericInput applies one number-pad key: -2 clears, -1 backspaces, and 0..9 append.
+// Callers retain their own validation and keyboard labels.
+func updateNumericInput(value, key int) int {
+	switch key {
+	case -2:
+		return 0
+	case -1:
+		if value > 0 {
+			return value / 10
+		}
+		return value
+	default:
+		return value*10 + key
+	}
+}

internal/web/service/tgbot/numeric_input_test.go

@@ -0,0 +1,81 @@
+package tgbot
+
+import (
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+func TestUpdateNumericInput(t *testing.T) {
+	tests := []struct {
+		name       string
+		value, key int
+		want       int
+	}{
+		{name: "append digit", value: 12, key: 3, want: 123},
+		{name: "append zero", value: 12, key: 0, want: 120},
+		{name: "backspace", value: 123, key: -1, want: 12},
+		{name: "backspace zero", value: 0, key: -1, want: 0},
+		{name: "clear", value: 123, key: -2, want: 0},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := updateNumericInput(tt.value, tt.key); got != tt.want {
+				t.Fatalf("updateNumericInput(%d, %d) = %d, want %d", tt.value, tt.key, got, tt.want)
+			}
+		})
+	}
+}
+
+func TestNumericInputTransitionIsUsedByEveryKeypad(t *testing.T) {
+	entries, err := os.ReadDir(".")
+	if err != nil {
+		t.Fatalf("read tgbot package: %v", err)
+	}
+	fset := token.NewFileSet()
+	for _, entry := range entries {
+		name := entry.Name()
+		if entry.IsDir() || filepath.Ext(name) != ".go" || name == "numeric_input.go" || filepath.Ext(strings.TrimSuffix(name, "_test.go")) != ".go" {
+			continue
+		}
+		parsed, err := parser.ParseFile(fset, name, nil, 0)
+		if err != nil {
+			t.Fatalf("parse %s: %v", name, err)
+		}
+		ast.Inspect(parsed, func(node ast.Node) bool {
+			switchStmt, ok := node.(*ast.SwitchStmt)
+			if !ok {
+				return true
+			}
+			hasClear, hasBackspace, hasDefault := false, false, false
+			for _, stmt := range switchStmt.Body.List {
+				clause := stmt.(*ast.CaseClause)
+				if clause.List == nil {
+					hasDefault = true
+				}
+				for _, expr := range clause.List {
+					hasClear = hasClear || numericKeyLiteral(expr, "2")
+					hasBackspace = hasBackspace || numericKeyLiteral(expr, "1")
+				}
+			}
+			if hasClear && hasBackspace && hasDefault {
+				position := fset.Position(switchStmt.Pos())
+				t.Errorf("open-coded numeric keypad transition at %s; use updateNumericInput", position)
+			}
+			return true
+		})
+	}
+}
+
+func numericKeyLiteral(expr ast.Expr, magnitude string) bool {
+	unary, ok := expr.(*ast.UnaryExpr)
+	if !ok || unary.Op != token.SUB {
+		return false
+	}
+	literal, ok := unary.X.(*ast.BasicLit)
+	return ok && literal.Kind == token.INT && literal.Value == magnitude
+}

internal/web/service/tgbot/tgbot.go

@@ -0,0 +1,537 @@
+package tgbot
+
+import (
+	"context"
+	"crypto/rand"
+	"embed"
+	"math/big"
+	"net/http"
+	"net/url"
+	"os"
+	"regexp"
+	"slices"
+	"strconv"
+	"strings"
+	"sync"
+	"time"
+
+	"github.com/mhsanaei/3x-ui/v3/internal/eventbus"
+	"github.com/mhsanaei/3x-ui/v3/internal/logger"
+	"github.com/mhsanaei/3x-ui/v3/internal/util/common"
+	"github.com/mhsanaei/3x-ui/v3/internal/web/global"
+	"github.com/mhsanaei/3x-ui/v3/internal/web/locale"
+	"github.com/mhsanaei/3x-ui/v3/internal/web/service"
+
+	"github.com/mymmrac/telego"
+	th "github.com/mymmrac/telego/telegohandler"
+	"github.com/valyala/fasthttp"
+	"github.com/valyala/fasthttp/fasthttpproxy"
+)
+
+var (
+	bot *telego.Bot
+
+	// botCancel stores the function to cancel the context, stopping Long Polling gracefully.
+	botCancel context.CancelFunc
+	// tgBotMutex protects concurrent access to botCancel variable
+	tgBotMutex sync.Mutex
+	// botWG waits for the OnReceive Long Polling goroutine to finish.
+	botWG sync.WaitGroup
+
+	botHandler  *th.BotHandler
+	adminIds    []int64
+	isRunning   bool
+	hostname    string
+	hashStorage *global.HashStorage
+
+	// EventBus is set from web layer to publish login/security events.
+	EventBus *eventbus.Bus
+
+	// Performance improvements
+	messageWorkerPool   chan struct{} // Semaphore for limiting concurrent message processing
+	optimizedHTTPClient *http.Client  // HTTP client with connection pooling and timeouts
+
+	// Simple cache for frequently accessed data
+	statusCache struct {
+		data      *service.Status
+		timestamp time.Time
+		mutex     sync.RWMutex
+	}
+
+	serverStatsCache struct {
+		data      string
+		timestamp time.Time
+		mutex     sync.RWMutex
+	}
+
+	// clients data to adding new client. receiver_inbound_IDs is the set of
+	// inbounds the new client will be attached to; receiver_inbound_ID mirrors
+	// the primary pick for the legacy attach-picker entry point. Per-protocol
+	// secrets (UUID, password, flow, method) are filled per-inbound on submit
+	// by ClientService.fillProtocolDefaults, so the bot only tracks universal
+	// client fields here.
+	receiver_inbound_ID  int
+	receiver_inbound_IDs []int
+	client_Email         string
+	client_LimitIP       int
+	client_TotalGB       int64
+	client_ExpiryTime    int64
+	client_Enable        bool
+	client_TgID          string
+	client_SubID         string
+	client_Comment       string
+	client_Reset         int
+)
+
+// userStateStore guards the per-chat conversation states. The Telegram command
+// and callback handlers run on a worker-pool goroutine while the message handler
+// runs on the dispatch goroutine, so a bare map would be a concurrent-map-write
+// crash. It also expires abandoned conversations so a user who starts a flow and
+// goes silent doesn't leave an entry forever.
+type userStateStore struct {
+	mu        sync.Mutex
+	states    map[int64]userStateEntry
+	lastPrune time.Time
+}
+
+type userStateEntry struct {
+	state string
+	at    time.Time
+}
+
+var userStateMgr = &userStateStore{states: make(map[int64]userStateEntry)}
+
+func (s *userStateStore) set(chatID int64, state string) {
+	s.mu.Lock()
+	s.states[chatID] = userStateEntry{state: state, at: time.Now()}
+	s.mu.Unlock()
+}
+
+func (s *userStateStore) get(chatID int64) (string, bool) {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	e, ok := s.states[chatID]
+	return e.state, ok
+}
+
+func (s *userStateStore) clear(chatID int64) {
+	s.mu.Lock()
+	delete(s.states, chatID)
+	s.mu.Unlock()
+}
+
+func (s *userStateStore) reset() {
+	s.mu.Lock()
+	s.states = make(map[int64]userStateEntry)
+	s.mu.Unlock()
+}
+
+// maybePrune drops conversations older than maxAge, at most once per maxAge so a
+// busy bot doesn't sweep the whole map on every message.
+func (s *userStateStore) maybePrune(maxAge time.Duration) {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	now := time.Now()
+	if now.Sub(s.lastPrune) < maxAge {
+		return
+	}
+	s.lastPrune = now
+	for id, e := range s.states {
+		if now.Sub(e.at) > maxAge {
+			delete(s.states, id)
+		}
+	}
+}
+
+// LoginStatus represents the result of a login attempt.
+type LoginStatus byte
+
+// Login status constants
+const (
+	LoginSuccess        LoginStatus = 1        // Login was successful
+	LoginFail           LoginStatus = 0        // Login failed
+	EmptyTelegramUserID             = int64(0) // Default value for empty Telegram user ID
+)
+
+// LoginAttempt contains safe metadata for panel login notifications.
+// It intentionally does not include attempted passwords.
+type LoginAttempt struct {
+	Username string
+	IP       string
+	Time     string
+	Status   LoginStatus
+	Reason   string
+}
+
+// Tgbot provides business logic for Telegram bot integration.
+// It handles bot commands, user interactions, and status reporting via Telegram.
+type Tgbot struct {
+	inboundService service.InboundService
+	clientService  service.ClientService
+	settingService service.SettingService
+	serverService  service.ServerService
+	xrayService    service.XrayService
+	lastStatus     *service.Status
+}
+
+// NewTgbot creates a new Tgbot instance.
+func (t *Tgbot) NewTgbot() *Tgbot {
+	return new(Tgbot)
+}
+
+// I18nBot retrieves a localized message for the bot interface.
+func (t *Tgbot) I18nBot(name string, params ...string) string {
+	return locale.I18n(locale.Bot, name, params...)
+}
+
+// GetHashStorage returns the hash storage instance for callback queries.
+func (t *Tgbot) GetHashStorage() *global.HashStorage {
+	return hashStorage
+}
+
+// getCachedStatus returns cached server status if it's fresh enough (less than 5 seconds old)
+func (t *Tgbot) getCachedStatus() (*service.Status, bool) {
+	statusCache.mutex.RLock()
+	defer statusCache.mutex.RUnlock()
+
+	if statusCache.data != nil && time.Since(statusCache.timestamp) < 5*time.Second {
+		return statusCache.data, true
+	}
+	return nil, false
+}
+
+// setCachedStatus updates the status cache
+func (t *Tgbot) setCachedStatus(status *service.Status) {
+	statusCache.mutex.Lock()
+	defer statusCache.mutex.Unlock()
+
+	statusCache.data = status
+	statusCache.timestamp = time.Now()
+}
+
+// getCachedServerStats returns cached server stats if it's fresh enough (less than 10 seconds old)
+func (t *Tgbot) getCachedServerStats() (string, bool) {
+	serverStatsCache.mutex.RLock()
+	defer serverStatsCache.mutex.RUnlock()
+
+	if serverStatsCache.data != "" && time.Since(serverStatsCache.timestamp) < 10*time.Second {
+		return serverStatsCache.data, true
+	}
+	return "", false
+}
+
+// setCachedServerStats updates the server stats cache
+func (t *Tgbot) setCachedServerStats(stats string) {
+	serverStatsCache.mutex.Lock()
+	defer serverStatsCache.mutex.Unlock()
+
+	serverStatsCache.data = stats
+	serverStatsCache.timestamp = time.Now()
+}
+
+// Start initializes and starts the Telegram bot with the provided translation files.
+func (t *Tgbot) Start(i18nFS embed.FS) error {
+	// Initialize localizer
+	err := locale.InitLocalizer(i18nFS, &t.settingService)
+	if err != nil {
+		return err
+	}
+
+	// If Start is called again (e.g. during reload), ensure any previous long-polling
+	// loop is stopped before creating a new bot / receiver.
+	StopBot()
+
+	// Initialize hash storage to store callback queries
+	hashStorage = global.NewHashStorage(20 * time.Minute)
+
+	// Initialize worker pool for concurrent message processing (max 10 concurrent handlers)
+	messageWorkerPool = make(chan struct{}, 10)
+
+	// Initialize optimized HTTP client with connection pooling
+	optimizedHTTPClient = &http.Client{
+		Timeout: 15 * time.Second,
+		Transport: &http.Transport{
+			MaxIdleConns:        100,
+			MaxIdleConnsPerHost: 10,
+			IdleConnTimeout:     30 * time.Second,
+			DisableKeepAlives:   false,
+		},
+	}
+
+	t.SetHostname()
+
+	// Get Telegram bot token
+	tgBotToken, err := t.settingService.GetTgBotToken()
+	if err != nil || tgBotToken == "" {
+		logger.Warning("Failed to get Telegram bot token:", err)
+		return err
+	}
+
+	// Get Telegram bot chat ID(s)
+	tgBotID, err := t.settingService.GetTgBotChatId()
+	if err != nil {
+		logger.Warning("Failed to get Telegram bot chat ID:", err)
+		return err
+	}
+
+	parsedAdminIds := make([]int64, 0)
+	// Parse admin IDs from comma-separated string
+	if tgBotID != "" {
+		for adminID := range strings.SplitSeq(tgBotID, ",") {
+			id, err := strconv.ParseInt(adminID, 10, 64)
+			if err != nil {
+				logger.Warning("Failed to parse admin ID from Telegram bot chat ID:", err)
+				return err
+			}
+			parsedAdminIds = append(parsedAdminIds, id)
+		}
+	}
+	tgBotMutex.Lock()
+	adminIds = parsedAdminIds
+	tgBotMutex.Unlock()
+
+	// Get Telegram bot proxy URL
+	tgBotProxy, err := t.settingService.GetTgBotProxy()
+	if err != nil {
+		logger.Warning("Failed to get Telegram bot proxy URL:", err)
+	}
+
+	// Fall back to the panel-wide egress bridge when no dedicated bot proxy is
+	// set. Resolved once at bot start: if Xray comes up later, the bot keeps
+	// its direct connection until it is restarted.
+	if tgBotProxy == "" {
+		if egress := t.settingService.PanelEgressProxyURL(); egress != "" && isSupportedBotProxyScheme(egress) {
+			tgBotProxy = egress
+		}
+	}
+
+	// Get Telegram bot API server URL
+	tgBotAPIServer, err := t.settingService.GetTgBotAPIServer()
+	if err != nil {
+		logger.Warning("Failed to get Telegram bot API server URL:", err)
+	}
+
+	// Create new Telegram bot instance
+	bot, err = t.NewBot(tgBotToken, tgBotProxy, tgBotAPIServer)
+	if err != nil {
+		logger.Error("Failed to initialize Telegram bot API:", err)
+		return err
+	}
+
+	t.trySetBotCommands(bot)
+
+	// Start receiving Telegram bot messages
+	tgBotMutex.Lock()
+	alreadyRunning := isRunning || botCancel != nil
+	tgBotMutex.Unlock()
+	if !alreadyRunning {
+		logger.Info("Telegram bot receiver started")
+		go t.OnReceive()
+	}
+
+	return nil
+}
+
+func (t *Tgbot) trySetBotCommands(bot *telego.Bot) {
+	defer func() {
+		if r := recover(); r != nil {
+			logger.Warning("Failed to register bot commands (Telegram may be rate-limiting); bot will continue without them:", r)
+		}
+	}()
+
+	err := bot.SetMyCommands(context.Background(), &telego.SetMyCommandsParams{
+		Commands: []telego.BotCommand{
+			{Command: "start", Description: t.I18nBot("tgbot.commands.startDesc")},
+			{Command: "help", Description: t.I18nBot("tgbot.commands.helpDesc")},
+			{Command: "status", Description: t.I18nBot("tgbot.commands.statusDesc")},
+			{Command: "id", Description: t.I18nBot("tgbot.commands.idDesc")},
+			{Command: "usage", Description: t.I18nBot("tgbot.commands.usageDesc")},
+			{Command: "inbound", Description: t.I18nBot("tgbot.commands.inboundDesc")},
+			{Command: "restart", Description: t.I18nBot("tgbot.commands.restartDesc")},
+			{Command: "clearall", Description: t.I18nBot("tgbot.commands.clearallDesc")},
+		},
+	})
+	if err != nil {
+		logger.Warning("Failed to set bot commands:", err)
+	}
+}
+
+func isSupportedBotProxyScheme(proxyUrl string) bool {
+	return strings.HasPrefix(proxyUrl, "socks5://") ||
+		strings.HasPrefix(proxyUrl, "http://") ||
+		strings.HasPrefix(proxyUrl, "https://")
+}
+
+// createRobustFastHTTPClient creates a fasthttp.Client with proper connection handling
+func (t *Tgbot) createRobustFastHTTPClient(proxyUrl string) *fasthttp.Client {
+	client := &fasthttp.Client{
+		// Connection timeouts
+		ReadTimeout:                   30 * time.Second,
+		WriteTimeout:                  30 * time.Second,
+		MaxIdleConnDuration:           60 * time.Second,
+		MaxConnDuration:               0, // unlimited, but controlled by MaxIdleConnDuration
+		MaxIdemponentCallAttempts:     3,
+		ReadBufferSize:                4096,
+		WriteBufferSize:               4096,
+		MaxConnsPerHost:               100,
+		MaxConnWaitTimeout:            10 * time.Second,
+		DisableHeaderNamesNormalizing: false,
+		DisablePathNormalizing:        false,
+		// resetTimeout stays false to keep the pre-RetryIfErr retry timing.
+		RetryIfErr: func(request *fasthttp.Request, _ int, _ error) (bool, bool) {
+			method := string(request.Header.Method())
+			return false, method == "GET" || method == "POST"
+		},
+	}
+
+	if proxyUrl != "" {
+		if strings.HasPrefix(proxyUrl, "socks5://") {
+			client.Dial = fasthttpproxy.FasthttpSocksDialer(proxyUrl)
+		} else {
+			client.Dial = fasthttpproxy.FasthttpHTTPDialer(proxyUrl)
+		}
+	}
+
+	return client
+}
+
+// NewBot creates a new Telegram bot instance with optional proxy and API server settings.
+func (t *Tgbot) NewBot(token string, proxyUrl string, apiServerUrl string) (*telego.Bot, error) {
+	// Validate proxy URL if provided
+	if proxyUrl != "" {
+		if !isSupportedBotProxyScheme(proxyUrl) {
+			logger.Warning("Unsupported proxy scheme (want socks5:// or http(s)://), ignoring proxy")
+			proxyUrl = "" // Clear invalid proxy
+		} else if _, err := url.Parse(proxyUrl); err != nil {
+			logger.Warningf("Can't parse proxy URL, ignoring proxy: %v", err)
+			proxyUrl = ""
+		}
+	}
+
+	// Validate API server URL if provided
+	if apiServerUrl != "" {
+		safeURL, err := service.SanitizePublicHTTPURL(apiServerUrl, false)
+		if err != nil {
+			logger.Warningf("Invalid or blocked API server URL, using default: %v", err)
+			apiServerUrl = ""
+		} else {
+			apiServerUrl = safeURL
+		}
+	}
+
+	// Create robust fasthttp client
+	client := t.createRobustFastHTTPClient(proxyUrl)
+
+	// Build bot options
+	var options []telego.BotOption
+	options = append(options, telego.WithFastHTTPClient(client))
+
+	if apiServerUrl != "" {
+		options = append(options, telego.WithAPIServer(apiServerUrl))
+	}
+
+	return telego.NewBot(token, options...)
+}
+
+// IsRunning checks if the Telegram bot is currently running.
+func (t *Tgbot) IsRunning() bool {
+	tgBotMutex.Lock()
+	defer tgBotMutex.Unlock()
+	return isRunning
+}
+
+// SetHostname sets the hostname for the bot.
+func (t *Tgbot) SetHostname() {
+	host, err := os.Hostname()
+	if err != nil {
+		logger.Error("get hostname error:", err)
+		hostname = ""
+		return
+	}
+	hostname = host
+}
+
+// Stop safely stops the Telegram bot's Long Polling operation.
+// This method now calls the global StopBot function and cleans up other resources.
+func (t *Tgbot) Stop() {
+	StopBot()
+	logger.Info("Stop Telegram receiver ...")
+	tgBotMutex.Lock()
+	adminIds = nil
+	tgBotMutex.Unlock()
+}
+
+// StopBot safely stops the Telegram bot's Long Polling operation by cancelling its context.
+// This is the global function called from main.go's signal handler and t.Stop().
+func StopBot() {
+	// Don't hold the mutex while cancelling/waiting.
+	tgBotMutex.Lock()
+	cancel := botCancel
+	botCancel = nil
+	handler := botHandler
+	botHandler = nil
+	isRunning = false
+	tgBotMutex.Unlock()
+
+	userStateMgr.reset()
+
+	if handler != nil {
+		_ = handler.Stop()
+	}
+
+	if cancel != nil {
+		logger.Info("Sending cancellation signal to Telegram bot...")
+		// Cancels the context passed to UpdatesViaLongPolling; this closes updates channel
+		// and lets botHandler.Start() exit cleanly.
+		cancel()
+		botWG.Wait()
+		logger.Info("Telegram bot successfully stopped.")
+	}
+}
+
+// encodeQuery encodes the query string if it's longer than 64 characters.
+func (t *Tgbot) encodeQuery(query string) string {
+	// NOTE: we only need to hash for more than 64 chars
+	if len(query) <= 64 {
+		return query
+	}
+
+	return hashStorage.SaveHash(query)
+}
+
+// decodeQuery decodes a hashed query string back to its original form.
+func (t *Tgbot) decodeQuery(query string) (string, error) {
+	if !hashStorage.IsMD5(query) {
+		return query, nil
+	}
+
+	decoded, exists := hashStorage.GetValue(query)
+	if !exists {
+		return "", common.NewError("hash not found in storage!")
+	}
+
+	return decoded, nil
+}
+
+// randomLowerAndNum generates a random string of lowercase letters and numbers.
+func (t *Tgbot) randomLowerAndNum(length int) string {
+	charset := "abcdefghijklmnopqrstuvwxyz0123456789"
+	bytes := make([]byte, length)
+	for i := range bytes {
+		randomIndex, _ := rand.Int(rand.Reader, big.NewInt(int64(len(charset))))
+		bytes[i] = charset[randomIndex.Int64()]
+	}
+	return string(bytes)
+}
+
+// int64Contains checks if an int64 slice contains a specific item.
+func int64Contains(slice []int64, item int64) bool {
+	return slices.Contains(slice, item)
+}
+
+// isSingleWord checks if the text contains only a single word.
+func (t *Tgbot) isSingleWord(text string) bool {
+	text = strings.TrimSpace(text)
+	re := regexp.MustCompile(`\s+`)
+	return re.MatchString(text)
+}

internal/web/service/tgbot/tgbot_callback_auth_test.go

@@ -0,0 +1,40 @@
+package tgbot
+
+import (
+	"testing"
+
+	"github.com/mymmrac/telego"
+)
+
+func TestAnswerCallbackDeniesPrivilegedActionToNonAdmin(t *testing.T) {
+	defer func() {
+		if r := recover(); r != nil {
+			t.Fatalf("a non-admin callback reached a privileged handler: %v", r)
+		}
+	}()
+
+	tg := &Tgbot{}
+	for _, data := range []string{"get_backup", "reset_all_traffics_c", "add_client", "onlines", "inbounds"} {
+		q := &telego.CallbackQuery{
+			Data:    data,
+			From:    telego.User{ID: 999999},
+			Message: &telego.Message{Chat: telego.Chat{ID: 1}},
+		}
+		tg.answerCallback(q, false)
+	}
+}
+
+func TestIsClientSelfCallback(t *testing.T) {
+	allowed := []string{"client_traffic", "client_sub_links", "client_qr_links", "client_sub_links alice@x"}
+	for _, d := range allowed {
+		if !isClientSelfCallback(d) {
+			t.Errorf("%q should be a per-user client callback", d)
+		}
+	}
+	denied := []string{"get_backup", "reset_all_traffics_c", "add_client", "onlines", "get_banlogs", "get_usage"}
+	for _, d := range denied {
+		if isClientSelfCallback(d) {
+			t.Errorf("%q is an admin-only callback and must not be treated as per-user", d)
+		}
+	}
+}

internal/web/service/tgbot/tgbot_client.go

@@ -0,0 +1,782 @@
+package tgbot
+
+import (
+	"context"
+	"encoding/base64"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"io"
+	"net/http"
+	"slices"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/mhsanaei/3x-ui/v3/internal/database/model"
+	"github.com/mhsanaei/3x-ui/v3/internal/logger"
+	"github.com/mhsanaei/3x-ui/v3/internal/util/common"
+	"github.com/mhsanaei/3x-ui/v3/internal/web/service"
+	"github.com/mhsanaei/3x-ui/v3/internal/xray"
+
+	"github.com/mymmrac/telego"
+	tu "github.com/mymmrac/telego/telegoutil"
+	"github.com/skip2/go-qrcode"
+)
+
+// BuildClientDraftMessage builds a protocol-neutral summary of the in-progress
+// client (email, attached inbounds, traffic limit, expiry, ip limit, comment)
+// shown in the multi-inbound add flow. Per-protocol secrets (UUID, password,
+// flow, method) are generated by fillProtocolDefaults on submit, so the bot
+// never has to track them per inbound itself.
+func (t *Tgbot) BuildClientDraftMessage() string {
+	now := time.Now().UnixMilli()
+
+	expiry := ""
+	switch {
+	case client_ExpiryTime == 0:
+		expiry = t.I18nBot("tgbot.unlimited")
+	case client_ExpiryTime < 0:
+		expiry = fmt.Sprintf("%d %s", client_ExpiryTime/-86400000, t.I18nBot("tgbot.days"))
+	default:
+		diff := client_ExpiryTime - now
+		if diff > 172800000 {
+			expiry = time.UnixMilli(client_ExpiryTime).Format("2006-01-02 15:04:05")
+		} else {
+			expiry = fmt.Sprintf("%d %s", diff/3600000, t.I18nBot("tgbot.hours"))
+		}
+	}
+
+	traffic := "♾️ Unlimited(Reset)"
+	if client_TotalGB > 0 {
+		traffic = common.FormatTraffic(client_TotalGB)
+	}
+
+	ipLimit := "♾️ Unlimited(Reset)"
+	if client_LimitIP > 0 {
+		ipLimit = fmt.Sprint(client_LimitIP)
+	}
+
+	attached := t.describeAttachedInbounds(receiver_inbound_IDs)
+	if attached == "" {
+		attached = "—"
+	}
+
+	comment := client_Comment
+	if comment == "" {
+		comment = "—"
+	}
+
+	tgID := client_TgID
+	if tgID == "" {
+		tgID = "—"
+	}
+
+	var b strings.Builder
+	b.WriteString("📝 *New client draft*\r\n")
+	fmt.Fprintf(&b, "📧 Email: `%s`\r\n", client_Email)
+	fmt.Fprintf(&b, "🔗 Attached: %s\r\n", attached)
+	fmt.Fprintf(&b, "📊 Traffic: %s\r\n", traffic)
+	fmt.Fprintf(&b, "📅 Expire: %s\r\n", expiry)
+	fmt.Fprintf(&b, "🔢 IP limit: %s\r\n", ipLimit)
+	fmt.Fprintf(&b, "👤 TG user: %s\r\n", tgID)
+	fmt.Fprintf(&b, "💬 Comment: %s\r\n", comment)
+	return b.String()
+}
+
+// describeAttachedInbounds returns a short "remark1, remark2" list for the given
+// inbound ids, falling back to "#id" when an inbound can't be loaded.
+func (t *Tgbot) describeAttachedInbounds(ids []int) string {
+	if len(ids) == 0 {
+		return ""
+	}
+	parts := make([]string, 0, len(ids))
+	for _, id := range ids {
+		ib, err := t.inboundService.GetInbound(id)
+		if err != nil || ib == nil {
+			parts = append(parts, fmt.Sprintf("#%d", id))
+			continue
+		}
+		label := ib.Remark
+		if label == "" {
+			label = fmt.Sprintf("#%d", id)
+		}
+		parts = append(parts, label)
+	}
+	return strings.Join(parts, ", ")
+}
+
+// SubmitAddClient sends the in-progress client to ClientService.Create with
+// the full set of attached inbound ids. Per-inbound fillProtocolDefaults on
+// the panel generates UUID/password/auth per protocol, so the bot only
+// supplies the universal fields it actually collected.
+func (t *Tgbot) SubmitAddClient() (bool, error) {
+	inboundIDs := receiver_inbound_IDs
+	if len(inboundIDs) == 0 && receiver_inbound_ID > 0 {
+		inboundIDs = []int{receiver_inbound_ID}
+	}
+	if len(inboundIDs) == 0 {
+		return false, errors.New(t.I18nBot("tgbot.answers.getInboundsFailed"))
+	}
+
+	tgIDInt, _ := strconv.ParseInt(client_TgID, 10, 64)
+	client := model.Client{
+		Email:      client_Email,
+		Enable:     client_Enable,
+		LimitIP:    client_LimitIP,
+		TotalGB:    client_TotalGB,
+		ExpiryTime: client_ExpiryTime,
+		SubID:      client_SubID,
+		Comment:    client_Comment,
+		Reset:      client_Reset,
+		TgID:       tgIDInt,
+	}
+
+	return t.clientService.Create(&t.inboundService, &service.ClientCreatePayload{
+		Client:     client,
+		InboundIds: inboundIDs,
+	})
+}
+
+// buildSubscriptionURLs builds the HTML sub page URL and JSON subscription URL for a client email
+func (t *Tgbot) buildSubscriptionURLs(email string) (string, string, error) {
+	// Resolve subId from client email
+	traffic, client, err := t.inboundService.GetClientByEmail(email)
+	_ = traffic
+	if err != nil || client == nil {
+		return "", "", errors.New("client not found")
+	}
+
+	// Gather settings to construct absolute URLs
+	subURI, _ := t.settingService.GetSubURI()
+	subJsonURI, _ := t.settingService.GetSubJsonURI()
+	subDomain, _ := t.settingService.GetSubDomain()
+	subPort, _ := t.settingService.GetSubPort()
+	subPath, _ := t.settingService.GetSubPath()
+	subJsonPath, _ := t.settingService.GetSubJsonPath()
+	subJsonEnable, _ := t.settingService.GetSubJsonEnable()
+	subKeyFile, _ := t.settingService.GetSubKeyFile()
+	subCertFile, _ := t.settingService.GetSubCertFile()
+
+	tls := (subKeyFile != "" && subCertFile != "")
+	scheme := "http"
+	if tls {
+		scheme = "https"
+	}
+
+	// Fallbacks
+	if subDomain == "" {
+		// try panel domain, otherwise OS hostname
+		if d, err := t.settingService.GetWebDomain(); err == nil && d != "" {
+			subDomain = d
+		} else if hostname != "" {
+			subDomain = hostname
+		} else {
+			subDomain = "localhost"
+		}
+	}
+
+	host := subDomain
+	if (subPort == 443 && tls) || (subPort == 80 && !tls) {
+		// standard ports: no port in host
+	} else {
+		host = fmt.Sprintf("%s:%d", subDomain, subPort)
+	}
+
+	// Ensure paths
+	if !strings.HasPrefix(subPath, "/") {
+		subPath = "/" + subPath
+	}
+	if !strings.HasSuffix(subPath, "/") {
+		subPath = subPath + "/"
+	}
+	if !strings.HasPrefix(subJsonPath, "/") {
+		subJsonPath = "/" + subJsonPath
+	}
+	if !strings.HasSuffix(subJsonPath, "/") {
+		subJsonPath = subJsonPath + "/"
+	}
+
+	var subURL string
+	var subJsonURL string
+
+	// If pre-configured URIs are available, use them directly
+	if subURI != "" {
+		if !strings.HasSuffix(subURI, "/") {
+			subURI = subURI + "/"
+		}
+		subURL = fmt.Sprintf("%s%s", subURI, client.SubID)
+	} else {
+		subURL = fmt.Sprintf("%s://%s%s%s", scheme, host, subPath, client.SubID)
+	}
+
+	if subJsonURI != "" {
+		if !strings.HasSuffix(subJsonURI, "/") {
+			subJsonURI = subJsonURI + "/"
+		}
+		subJsonURL = fmt.Sprintf("%s%s", subJsonURI, client.SubID)
+	} else {
+		subJsonURL = fmt.Sprintf("%s://%s%s%s", scheme, host, subJsonPath, client.SubID)
+	}
+
+	if !subJsonEnable {
+		subJsonURL = ""
+	}
+	return subURL, subJsonURL, nil
+}
+
+// sendClientSubLinks sends the subscription links for the client to the chat.
+func (t *Tgbot) sendClientSubLinks(chatId int64, email string) {
+	subURL, subJsonURL, err := t.buildSubscriptionURLs(email)
+	if err != nil {
+		t.SendMsgToTgbot(chatId, t.I18nBot("tgbot.answers.errorOperation")+"\r\n"+err.Error())
+		return
+	}
+	msg := "Subscription URL:\r\n<code>" + subURL + "</code>"
+	if subJsonURL != "" {
+		msg += "\r\n\r\nJSON URL:\r\n<code>" + subJsonURL + "</code>"
+	}
+	inlineKeyboard := tu.InlineKeyboard(
+		tu.InlineKeyboardRow(
+			tu.InlineKeyboardButton(t.I18nBot("subscription.individualLinks")).WithCallbackData(t.encodeQuery("client_individual_links "+email)),
+		),
+		tu.InlineKeyboardRow(
+			tu.InlineKeyboardButton(t.I18nBot("qrCode")).WithCallbackData(t.encodeQuery("client_qr_links "+email)),
+		),
+	)
+	t.SendMsgToTgbot(chatId, msg, inlineKeyboard)
+}
+
+// sendClientIndividualLinks fetches the subscription content (individual links) and sends it to the user
+func (t *Tgbot) sendClientIndividualLinks(chatId int64, email string) {
+	// Build the HTML sub page URL; we'll call it with header Accept to get raw content
+	subURL, _, err := t.buildSubscriptionURLs(email)
+	if err != nil {
+		t.SendMsgToTgbot(chatId, t.I18nBot("tgbot.answers.errorOperation")+"\r\n"+err.Error())
+		return
+	}
+
+	// Try to fetch raw subscription links. Prefer plain text response.
+	req, err := http.NewRequestWithContext(context.Background(), http.MethodGet, subURL, nil)
+	if err != nil {
+		t.SendMsgToTgbot(chatId, t.I18nBot("tgbot.answers.errorOperation")+"\r\n"+err.Error())
+		return
+	}
+	// Force plain text to avoid HTML page; controller respects Accept header
+	req.Header.Set("Accept", "text/plain, */*;q=0.1")
+
+	// Use optimized client with connection pooling
+	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+	defer cancel()
+	req = req.WithContext(ctx)
+
+	resp, err := optimizedHTTPClient.Do(req)
+	if err != nil {
+		t.SendMsgToTgbot(chatId, t.I18nBot("tgbot.answers.errorOperation")+"\r\n"+err.Error())
+		return
+	}
+	defer resp.Body.Close()
+
+	bodyBytes, err := io.ReadAll(resp.Body)
+	if err != nil {
+		t.SendMsgToTgbot(chatId, t.I18nBot("tgbot.answers.errorOperation")+"\r\n"+err.Error())
+		return
+	}
+
+	// If service is configured to encode (Base64), decode it
+	encoded, _ := t.settingService.GetSubEncrypt()
+	var content string
+	if encoded {
+		decoded, err := base64.StdEncoding.DecodeString(string(bodyBytes))
+		if err != nil {
+			// fallback to raw text
+			content = string(bodyBytes)
+		} else {
+			content = string(decoded)
+		}
+	} else {
+		content = string(bodyBytes)
+	}
+
+	// Normalize line endings and trim
+	lines := strings.Split(strings.ReplaceAll(content, "\r\n", "\n"), "\n")
+	var cleaned []string
+	for _, l := range lines {
+		l = strings.TrimSpace(l)
+		if l != "" {
+			cleaned = append(cleaned, l)
+		}
+	}
+	if len(cleaned) == 0 {
+		t.SendMsgToTgbot(chatId, t.I18nBot("tgbot.noResult"))
+		return
+	}
+
+	// Send in chunks to respect message length; use monospace formatting
+	const maxPerMessage = 50
+	for i := 0; i < len(cleaned); i += maxPerMessage {
+		j := min(i+maxPerMessage, len(cleaned))
+		chunk := cleaned[i:j]
+		var msg strings.Builder
+		msg.WriteString(t.I18nBot("subscription.individualLinks"))
+		msg.WriteString(":\r\n")
+		for _, link := range chunk {
+			// wrap each link in <code>
+			msg.WriteString("<code>")
+			msg.WriteString(link)
+			msg.WriteString("</code>\r\n")
+		}
+		t.SendMsgToTgbot(chatId, msg.String())
+	}
+}
+
+// sendClientQRLinks generates QR images for subscription URL, JSON URL, and a few individual links, then sends them
+func (t *Tgbot) sendClientQRLinks(chatId int64, email string) {
+	subURL, subJsonURL, err := t.buildSubscriptionURLs(email)
+	if err != nil {
+		t.SendMsgToTgbot(chatId, t.I18nBot("tgbot.answers.errorOperation")+"\r\n"+err.Error())
+		return
+	}
+
+	// Helper to create QR PNG bytes from content
+	createQR := func(content string, size int) ([]byte, error) {
+		if size <= 0 {
+			size = 256
+		}
+		return qrcode.Encode(content, qrcode.Medium, size)
+	}
+
+	// Inform user
+	t.SendMsgToTgbot(chatId, "QRCode for client "+email+":")
+
+	// Send sub URL QR (filename: sub.png)
+	if png, err := createQR(subURL, 320); err == nil {
+		document := tu.Document(
+			tu.ID(chatId),
+			tu.FileFromBytes(png, "sub.png"),
+		)
+		_, _ = bot.SendDocument(context.Background(), document)
+	} else {
+		t.SendMsgToTgbot(chatId, t.I18nBot("tgbot.answers.errorOperation")+"\r\n"+err.Error())
+	}
+
+	// Send JSON URL QR (filename: subjson.png) when available
+	if subJsonURL != "" {
+		if png, err := createQR(subJsonURL, 320); err == nil {
+			document := tu.Document(
+				tu.ID(chatId),
+				tu.FileFromBytes(png, "subjson.png"),
+			)
+			_, _ = bot.SendDocument(context.Background(), document)
+		} else {
+			t.SendMsgToTgbot(chatId, t.I18nBot("tgbot.answers.errorOperation")+"\r\n"+err.Error())
+		}
+	}
+
+	// Also generate a few individual links' QRs (first up to 5)
+	subPageURL := subURL
+	req, err := http.NewRequestWithContext(context.Background(), http.MethodGet, subPageURL, nil)
+	if err == nil {
+		req.Header.Set("Accept", "text/plain, */*;q=0.1")
+		ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+		defer cancel()
+		req = req.WithContext(ctx)
+		if resp, err := optimizedHTTPClient.Do(req); err == nil {
+			body, _ := io.ReadAll(resp.Body)
+			_ = resp.Body.Close()
+			encoded, _ := t.settingService.GetSubEncrypt()
+			var content string
+			if encoded {
+				if dec, err := base64.StdEncoding.DecodeString(string(body)); err == nil {
+					content = string(dec)
+				} else {
+					content = string(body)
+				}
+			} else {
+				content = string(body)
+			}
+			lines := strings.Split(strings.ReplaceAll(content, "\r\n", "\n"), "\n")
+			var cleaned []string
+			for _, l := range lines {
+				l = strings.TrimSpace(l)
+				if l != "" {
+					cleaned = append(cleaned, l)
+				}
+			}
+			if len(cleaned) > 0 {
+				max := min(len(cleaned), 5)
+				for i := range max {
+					if png, err := createQR(cleaned[i], 320); err == nil {
+						// Use the email as filename for individual link QR
+						filename := email + ".png"
+						document := tu.Document(
+							tu.ID(chatId),
+							tu.FileFromBytes(png, filename),
+						)
+						_, _ = bot.SendDocument(context.Background(), document)
+						// Reduced delay for better performance
+						if i < max-1 { // Only delay between documents, not after the last one
+							time.Sleep(50 * time.Millisecond)
+						}
+					}
+				}
+			}
+		}
+	}
+}
+
+// clientInfoMsg formats client information message based on traffic and flags.
+func (t *Tgbot) clientInfoMsg(
+	traffic *xray.ClientTraffic,
+	printEnabled bool,
+	printOnline bool,
+	printActive bool,
+	printDate bool,
+	printTraffic bool,
+	printRefreshed bool,
+) string {
+	now := time.Now().Unix()
+	expiryTime := ""
+	flag := false
+	diff := traffic.ExpiryTime/1000 - now
+	if traffic.ExpiryTime == 0 {
+		expiryTime = t.I18nBot("tgbot.unlimited")
+	} else if diff > 172800 || !traffic.Enable {
+		expiryTime = time.Unix((traffic.ExpiryTime / 1000), 0).Format("2006-01-02 15:04:05")
+		if diff > 0 {
+			days := diff / 86400
+			hours := (diff % 86400) / 3600
+			minutes := (diff % 3600) / 60
+			remainingTime := ""
+			if days > 0 {
+				remainingTime += fmt.Sprintf("%d %s ", days, t.I18nBot("tgbot.days"))
+			}
+			if hours > 0 {
+				remainingTime += fmt.Sprintf("%d %s ", hours, t.I18nBot("tgbot.hours"))
+			}
+			if minutes > 0 {
+				remainingTime += fmt.Sprintf("%d %s", minutes, t.I18nBot("tgbot.minutes"))
+			}
+			expiryTime += fmt.Sprintf(" (%s)", remainingTime)
+		}
+	} else if traffic.ExpiryTime < 0 {
+		expiryTime = fmt.Sprintf("%d %s", traffic.ExpiryTime/-86400000, t.I18nBot("tgbot.days"))
+		flag = true
+	} else {
+		expiryTime = fmt.Sprintf("%d %s", diff/3600, t.I18nBot("tgbot.hours"))
+		flag = true
+	}
+
+	total := ""
+	if traffic.Total == 0 {
+		total = t.I18nBot("tgbot.unlimited")
+	} else {
+		total = common.FormatTraffic(traffic.Total)
+	}
+
+	enabled := ""
+	isEnabled, err := t.clientService.CheckIsEnabledByEmail(&t.inboundService, traffic.Email)
+	if err != nil {
+		logger.Warning(err)
+		enabled = t.I18nBot("tgbot.wentWrong")
+	} else if isEnabled {
+		enabled = t.I18nBot("tgbot.messages.yes")
+	} else {
+		enabled = t.I18nBot("tgbot.messages.no")
+	}
+
+	active := ""
+	if traffic.Enable {
+		active = t.I18nBot("tgbot.messages.yes")
+	} else {
+		active = t.I18nBot("tgbot.messages.no")
+	}
+
+	status := t.I18nBot("tgbot.offline")
+	isOnline := false
+	if process := service.XrayProcess(); process != nil && process.IsRunning() {
+		if slices.Contains(process.GetOnlineClients(), traffic.Email) {
+			status = t.I18nBot("tgbot.online")
+			isOnline = true
+		}
+	}
+
+	output := ""
+	output += t.I18nBot("tgbot.messages.email", "Email=="+traffic.Email)
+	if attachIds, err := t.clientService.GetInboundIdsForEmail(nil, traffic.Email); err == nil && len(attachIds) > 0 {
+		output += fmt.Sprintf("🔗 Inbounds: %s\r\n", t.describeAttachedInbounds(attachIds))
+	}
+	if printEnabled {
+		output += t.I18nBot("tgbot.messages.enabled", "Enable=="+enabled)
+	}
+	if printOnline {
+		output += t.I18nBot("tgbot.messages.online", "Status=="+status)
+		if !isOnline && traffic.LastOnline > 0 {
+			output += t.I18nBot("tgbot.messages.lastOnline", "Time=="+time.UnixMilli(traffic.LastOnline).Format("2006-01-02 15:04:05"))
+		}
+	}
+	if printActive {
+		output += t.I18nBot("tgbot.messages.active", "Enable=="+active)
+	}
+	if printDate {
+		if flag {
+			output += t.I18nBot("tgbot.messages.expireIn", "Time=="+expiryTime)
+		} else {
+			output += t.I18nBot("tgbot.messages.expire", "Time=="+expiryTime)
+		}
+	}
+	if printTraffic {
+		output += t.I18nBot("tgbot.messages.upload", "Upload=="+common.FormatTraffic(traffic.Up))
+		output += t.I18nBot("tgbot.messages.download", "Download=="+common.FormatTraffic(traffic.Down))
+		output += t.I18nBot("tgbot.messages.total", "UpDown=="+common.FormatTraffic((traffic.Up+traffic.Down)), "Total=="+total)
+	}
+	if printRefreshed {
+		output += t.I18nBot("tgbot.messages.refreshedOn", "Time=="+time.Now().Format("2006-01-02 15:04:05"))
+	}
+
+	return output
+}
+
+// getClientUsage retrieves and sends client usage information to the chat.
+func (t *Tgbot) getClientUsage(chatId int64, tgUserID int64, email ...string) {
+	traffics, err := t.inboundService.GetClientTrafficTgBot(tgUserID)
+	if err != nil {
+		logger.Warning(err)
+		msg := t.I18nBot("tgbot.wentWrong")
+		t.SendMsgToTgbot(chatId, msg)
+		return
+	}
+
+	if len(traffics) == 0 {
+		t.SendMsgToTgbot(chatId, t.I18nBot("tgbot.answers.askToAddUserId", "TgUserID=="+strconv.FormatInt(tgUserID, 10)))
+		return
+	}
+
+	output := ""
+
+	if len(traffics) > 0 {
+		if len(email) > 0 {
+			for _, traffic := range traffics {
+				if traffic.Email == email[0] {
+					output := t.clientInfoMsg(traffic, true, true, true, true, true, true)
+					t.SendMsgToTgbot(chatId, output)
+					return
+				}
+			}
+			msg := t.I18nBot("tgbot.noResult")
+			t.SendMsgToTgbot(chatId, msg)
+			return
+		} else {
+			for _, traffic := range traffics {
+				output += t.clientInfoMsg(traffic, true, true, true, true, true, false)
+				output += "\r\n"
+			}
+		}
+	}
+
+	output += t.I18nBot("tgbot.messages.refreshedOn", "Time=="+time.Now().Format("2006-01-02 15:04:05"))
+	t.SendMsgToTgbot(chatId, output)
+	output = t.I18nBot("tgbot.commands.pleaseChoose")
+	t.SendAnswer(chatId, output, false)
+}
+
+// searchClientIps searches and sends client IP addresses for the given email.
+func (t *Tgbot) searchClientIps(chatId int64, email string, messageID ...int) {
+	ips, err := t.inboundService.GetInboundClientIps(email)
+	if err != nil || len(ips) == 0 {
+		ips = t.I18nBot("tgbot.noIpRecord")
+	}
+
+	formattedIps := ips
+	if err == nil && len(ips) > 0 {
+		type ipWithTimestamp struct {
+			IP        string `json:"ip"`
+			Timestamp int64  `json:"timestamp"`
+		}
+
+		var ipsWithTime []ipWithTimestamp
+		if json.Unmarshal([]byte(ips), &ipsWithTime) == nil && len(ipsWithTime) > 0 {
+			lines := make([]string, 0, len(ipsWithTime))
+			for _, item := range ipsWithTime {
+				if item.IP == "" {
+					continue
+				}
+				if item.Timestamp > 0 {
+					ts := time.Unix(item.Timestamp, 0).Format("2006-01-02 15:04:05")
+					lines = append(lines, fmt.Sprintf("%s (%s)", item.IP, ts))
+					continue
+				}
+				lines = append(lines, item.IP)
+			}
+			if len(lines) > 0 {
+				formattedIps = strings.Join(lines, "\n")
+			}
+		} else {
+			var oldIps []string
+			if json.Unmarshal([]byte(ips), &oldIps) == nil && len(oldIps) > 0 {
+				formattedIps = strings.Join(oldIps, "\n")
+			}
+		}
+	}
+
+	output := ""
+	output += t.I18nBot("tgbot.messages.email", "Email=="+email)
+	output += t.I18nBot("tgbot.messages.ips", "IPs=="+formattedIps)
+	output += t.I18nBot("tgbot.messages.refreshedOn", "Time=="+time.Now().Format("2006-01-02 15:04:05"))
+
+	inlineKeyboard := tu.InlineKeyboard(
+		tu.InlineKeyboardRow(
+			tu.InlineKeyboardButton(t.I18nBot("tgbot.buttons.refresh")).WithCallbackData(t.encodeQuery("ips_refresh "+email)),
+		),
+		tu.InlineKeyboardRow(
+			tu.InlineKeyboardButton(t.I18nBot("tgbot.buttons.clearIPs")).WithCallbackData(t.encodeQuery("clear_ips "+email)),
+		),
+	)
+
+	if len(messageID) > 0 {
+		t.editMessageTgBot(chatId, messageID[0], output, inlineKeyboard)
+	} else {
+		t.SendMsgToTgbot(chatId, output, inlineKeyboard)
+	}
+}
+
+// clientTelegramUserInfo retrieves and sends Telegram user info for the client.
+func (t *Tgbot) clientTelegramUserInfo(chatId int64, email string, messageID ...int) {
+	traffic, client, err := t.inboundService.GetClientByEmail(email)
+	if err != nil {
+		logger.Warning(err)
+		msg := t.I18nBot("tgbot.wentWrong")
+		t.SendMsgToTgbot(chatId, msg)
+		return
+	}
+	if client == nil {
+		msg := t.I18nBot("tgbot.noResult")
+		t.SendMsgToTgbot(chatId, msg)
+		return
+	}
+	tgId := "None"
+	if client.TgID != 0 {
+		tgId = strconv.FormatInt(client.TgID, 10)
+	}
+
+	output := ""
+	output += t.I18nBot("tgbot.messages.email", "Email=="+email)
+	output += t.I18nBot("tgbot.messages.TGUser", "TelegramID=="+tgId)
+	output += t.I18nBot("tgbot.messages.refreshedOn", "Time=="+time.Now().Format("2006-01-02 15:04:05"))
+
+	inlineKeyboard := tu.InlineKeyboard(
+		tu.InlineKeyboardRow(
+			tu.InlineKeyboardButton(t.I18nBot("tgbot.buttons.refresh")).WithCallbackData(t.encodeQuery("tgid_refresh "+email)),
+		),
+		tu.InlineKeyboardRow(
+			tu.InlineKeyboardButton(t.I18nBot("tgbot.buttons.removeTGUser")).WithCallbackData(t.encodeQuery("tgid_remove "+email)),
+		),
+	)
+
+	if len(messageID) > 0 {
+		t.editMessageTgBot(chatId, messageID[0], output, inlineKeyboard)
+	} else {
+		t.SendMsgToTgbot(chatId, output, inlineKeyboard)
+		requestUser := telego.KeyboardButtonRequestUsers{
+			RequestID: int32(traffic.Id),
+			UserIsBot: new(bool),
+		}
+		keyboard := tu.Keyboard(
+			tu.KeyboardRow(
+				tu.KeyboardButton(t.I18nBot("tgbot.buttons.selectTGUser")).WithRequestUsers(&requestUser),
+			),
+			tu.KeyboardRow(
+				tu.KeyboardButton(t.I18nBot("tgbot.buttons.closeKeyboard")),
+			),
+		).WithIsPersistent().WithResizeKeyboard()
+		t.SendMsgToTgbot(chatId, t.I18nBot("tgbot.buttons.selectOneTGUser"), keyboard)
+	}
+}
+
+// searchClient searches for a client by email and sends the information.
+func (t *Tgbot) searchClient(chatId int64, email string, messageID ...int) {
+	traffic, err := t.inboundService.GetClientTrafficByEmail(email)
+	if err != nil {
+		logger.Warning(err)
+		msg := t.I18nBot("tgbot.wentWrong")
+		t.SendMsgToTgbot(chatId, msg)
+		return
+	}
+	if traffic == nil {
+		msg := t.I18nBot("tgbot.noResult")
+		t.SendMsgToTgbot(chatId, msg)
+		return
+	}
+
+	output := t.clientInfoMsg(traffic, true, true, true, true, true, true)
+
+	inlineKeyboard := tu.InlineKeyboard(
+		tu.InlineKeyboardRow(
+			tu.InlineKeyboardButton(t.I18nBot("tgbot.buttons.refresh")).WithCallbackData(t.encodeQuery("client_refresh "+email)),
+		),
+		tu.InlineKeyboardRow(
+			tu.InlineKeyboardButton(t.I18nBot("tgbot.buttons.resetTraffic")).WithCallbackData(t.encodeQuery("reset_traffic "+email)),
+			tu.InlineKeyboardButton(t.I18nBot("tgbot.buttons.limitTraffic")).WithCallbackData(t.encodeQuery("limit_traffic "+email)),
+		),
+		tu.InlineKeyboardRow(
+			tu.InlineKeyboardButton(t.I18nBot("tgbot.buttons.resetExpire")).WithCallbackData(t.encodeQuery("reset_exp "+email)),
+		),
+		tu.InlineKeyboardRow(
+			tu.InlineKeyboardButton(t.I18nBot("tgbot.buttons.ipLog")).WithCallbackData(t.encodeQuery("ip_log "+email)),
+			tu.InlineKeyboardButton(t.I18nBot("tgbot.buttons.ipLimit")).WithCallbackData(t.encodeQuery("ip_limit "+email)),
+		),
+		tu.InlineKeyboardRow(
+			tu.InlineKeyboardButton(t.I18nBot("tgbot.buttons.setTGUser")).WithCallbackData(t.encodeQuery("tg_user "+email)),
+		),
+		tu.InlineKeyboardRow(
+			tu.InlineKeyboardButton(t.I18nBot("tgbot.buttons.toggle")).WithCallbackData(t.encodeQuery("toggle_enable "+email)),
+		),
+	)
+	if len(messageID) > 0 {
+		t.editMessageTgBot(chatId, messageID[0], output, inlineKeyboard)
+	} else {
+		t.SendMsgToTgbot(chatId, output, inlineKeyboard)
+	}
+}
+
+// getCommonClientButtons returns the shared inline keyboard rows for the
+// client-first multi-inbound add flow. Per-protocol secrets (UUID, password,
+// flow, method) are generated by fillProtocolDefaults on submit, so the bot
+// only exposes the universal client fields here.
+func (t *Tgbot) getCommonClientButtons() [][]telego.InlineKeyboardButton {
+	attachLabel := fmt.Sprintf("➕ Attach inbound (%d)", len(receiver_inbound_IDs))
+	return [][]telego.InlineKeyboardButton{
+		tu.InlineKeyboardRow(
+			tu.InlineKeyboardButton(t.I18nBot("tgbot.buttons.change_email")).WithCallbackData("add_client_ch_default_email"),
+			tu.InlineKeyboardButton(t.I18nBot("tgbot.buttons.change_comment")).WithCallbackData("add_client_ch_default_comment"),
+		),
+		tu.InlineKeyboardRow(
+			tu.InlineKeyboardButton(t.I18nBot("tgbot.buttons.limitTraffic")).WithCallbackData("add_client_ch_default_traffic"),
+			tu.InlineKeyboardButton(t.I18nBot("tgbot.buttons.resetExpire")).WithCallbackData("add_client_ch_default_exp"),
+		),
+		tu.InlineKeyboardRow(
+			tu.InlineKeyboardButton(t.I18nBot("tgbot.buttons.ipLimit")).WithCallbackData("add_client_ch_default_ip_limit"),
+			tu.InlineKeyboardButton(t.I18nBot("tgbot.buttons.setTGUser")).WithCallbackData("add_client_ch_default_tg_id"),
+		),
+		tu.InlineKeyboardRow(
+			tu.InlineKeyboardButton(attachLabel).WithCallbackData("add_client_attach_more"),
+		),
+		tu.InlineKeyboardRow(
+			tu.InlineKeyboardButton(t.I18nBot("tgbot.buttons.submitDisable")).WithCallbackData("add_client_submit_disable"),
+			tu.InlineKeyboardButton(t.I18nBot("tgbot.buttons.submitEnable")).WithCallbackData("add_client_submit_enable"),
+		),
+		tu.InlineKeyboardRow(
+			tu.InlineKeyboardButton(t.I18nBot("tgbot.buttons.cancel")).WithCallbackData("add_client_cancel"),
+		),
+	}
+}
+
+// addClient renders the draft message + shared client-first keyboard.
+func (t *Tgbot) addClient(chatId int64, msg string, messageID ...int) {
+	inlineKeyboard := tu.InlineKeyboard(t.getCommonClientButtons()...)
+	if len(messageID) > 0 {
+		t.editMessageTgBot(chatId, messageID[0], msg, inlineKeyboard)
+	} else {
+		t.SendMsgToTgbot(chatId, msg, inlineKeyboard)
+	}
+}

internal/web/service/tgbot/tgbot_delete_after_test.go

@@ -0,0 +1,18 @@
+package tgbot
+
+import "testing"
+
+func TestDeleteMessageAfterDelayKeepsUserState(t *testing.T) {
+	userStateMgr.reset()
+	t.Cleanup(userStateMgr.reset)
+
+	const chatID = int64(4242)
+	userStateMgr.set(chatID, "awaiting_comment")
+
+	tg := &Tgbot{}
+	tg.deleteMessageAfterDelay(chatID, 1, 0)
+
+	if st, ok := userStateMgr.get(chatID); !ok || st != "awaiting_comment" {
+		t.Fatalf("delayed message deletion cleared the conversation state: got (%q, %v), want (%q, true)", st, ok, "awaiting_comment")
+	}
+}

internal/web/service/tgbot/tgbot_event.go

@@ -0,0 +1,162 @@
+package tgbot
+
+import (
+	"fmt"
+	"os"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/mhsanaei/3x-ui/v3/internal/eventbus"
+)
+
+var cachedHostname string
+
+func getHostname() string {
+	if cachedHostname != "" {
+		return cachedHostname
+	}
+	h, err := os.Hostname()
+	if err != nil {
+		cachedHostname = "unknown"
+	} else {
+		cachedHostname = h
+	}
+	return cachedHostname
+}
+
+var tgEventLimiter = eventbus.NewRateLimiter(1 * time.Minute)
+
+// HandleEvent is the eventbus subscriber callback. It formats incoming events
+// as Telegram messages and sends them to all admin chats.
+func (t *Tgbot) HandleEvent(e eventbus.Event) {
+	if !t.isEventEnabled(e.Type) {
+		return
+	}
+	if e.Type != eventbus.EventLoginAttempt {
+		if !tgEventLimiter.Allow(e.Type, e.Source) {
+			return
+		}
+	}
+	msg := t.formatEventMessage(e)
+	if msg != "" {
+		t.SendMsgToTgbotAdmins(msg)
+	}
+}
+
+func (t *Tgbot) isEventEnabled(eventType eventbus.EventType) bool {
+	events, err := t.settingService.GetTgEnabledEvents()
+	if err != nil || events == "" {
+		return false
+	}
+	for e := range strings.SplitSeq(events, ",") {
+		if strings.TrimSpace(e) == string(eventType) {
+			return true
+		}
+	}
+	return false
+}
+
+func (t *Tgbot) formatEventMessage(e eventbus.Event) string {
+	host := getHostname()
+	header := fmt.Sprintf("<b>📡 %s</b>\n", host)
+
+	switch e.Type {
+	case eventbus.EventOutboundDown:
+		msg := header + t.I18nBot("tgbot.messages.eventOutboundDown",
+			"Tag=="+e.Source)
+		if data, ok := e.Data.(*eventbus.OutboundHealthData); ok {
+			if data.Error != "" {
+				msg += "\n" + t.I18nBot("tgbot.messages.eventErrorDetail",
+					"Error=="+data.Error)
+			}
+			if data.Delay > 0 {
+				msg += "\n" + t.I18nBot("tgbot.messages.eventDelayDetail",
+					"Delay=="+fmt.Sprintf("%d", data.Delay))
+			}
+		}
+		return msg
+
+	case eventbus.EventOutboundUp:
+		msg := header + t.I18nBot("tgbot.messages.eventOutboundUp",
+			"Tag=="+e.Source)
+		if data, ok := e.Data.(*eventbus.OutboundHealthData); ok && data.Delay > 0 {
+			msg += "\n" + t.I18nBot("tgbot.messages.eventDelayDetail",
+				"Delay=="+fmt.Sprintf("%d", data.Delay))
+		}
+		return msg
+
+	case eventbus.EventXrayCrash:
+		errStr := ""
+		if e.Data != nil {
+			errStr = fmt.Sprint(e.Data)
+		}
+		msg := header + "🔥 " + t.I18nBot("tgbot.messages.eventXrayCrash")
+		if errStr != "" {
+			msg += "\n" + t.I18nBot("tgbot.messages.eventXrayCrashError", "Error=="+errStr)
+		}
+		return msg
+
+	case eventbus.EventNodeDown:
+		msg := header + "🔴 " + t.I18nBot("tgbot.messages.eventNodeDown", "Name=="+e.Source)
+		if data, ok := e.Data.(*eventbus.NodeHealthData); ok && data.XrayError != "" {
+			msg += "\n" + t.I18nBot("tgbot.messages.eventErrorDetail", "Error=="+data.XrayError)
+		}
+		return msg
+
+	case eventbus.EventNodeUp:
+		msg := header + "🟢 " + t.I18nBot("tgbot.messages.eventNodeUp", "Name=="+e.Source)
+		if data, ok := e.Data.(*eventbus.NodeHealthData); ok && data.LatencyMs > 0 {
+			msg += "\n" + t.I18nBot("tgbot.messages.eventDelayDetail", "Delay=="+fmt.Sprintf("%d", data.LatencyMs))
+		}
+		return msg
+
+	case eventbus.EventCPUHigh:
+		if data, ok := e.Data.(*eventbus.SystemMetricData); ok {
+			tgCpu, err := t.settingService.GetTgCpu()
+			if err != nil || tgCpu <= 0 || data.Percent <= float64(tgCpu) {
+				return ""
+			}
+			return header + "🔴 " + t.I18nBot("tgbot.messages.cpuThreshold",
+				"Percent=="+strconv.FormatFloat(data.Percent, 'f', 2, 64),
+				"Threshold=="+strconv.Itoa(tgCpu))
+		}
+		return ""
+
+	case eventbus.EventMemoryHigh:
+		if data, ok := e.Data.(*eventbus.SystemMetricData); ok {
+			tgMemory, err := t.settingService.GetTgMemory()
+			if err != nil || tgMemory <= 0 || data.Percent <= float64(tgMemory) {
+				return ""
+			}
+			return header + "🔴 " + t.I18nBot("tgbot.messages.memoryThreshold",
+				"Percent=="+strconv.FormatFloat(data.Percent, 'f', 2, 64),
+				"Threshold=="+strconv.Itoa(tgMemory))
+		}
+		return ""
+
+	case eventbus.EventLoginAttempt:
+		if data, ok := e.Data.(*eventbus.LoginEventData); ok {
+			if data.Status == "success" {
+				msg := t.I18nBot("tgbot.messages.loginSuccess")
+				msg += t.I18nBot("tgbot.messages.hostname", "Hostname=="+host)
+				msg += t.I18nBot("tgbot.messages.username", "Username=="+data.Username)
+				msg += t.I18nBot("tgbot.messages.ip", "IP=="+data.IP)
+				msg += t.I18nBot("tgbot.messages.time", "Time=="+data.Time)
+				return msg
+			}
+			msg := t.I18nBot("tgbot.messages.loginFailed")
+			msg += t.I18nBot("tgbot.messages.hostname", "Hostname=="+host)
+			if data.Reason != "" {
+				msg += t.I18nBot("tgbot.messages.reason", "Reason=="+data.Reason)
+			}
+			msg += t.I18nBot("tgbot.messages.username", "Username=="+data.Username)
+			msg += t.I18nBot("tgbot.messages.ip", "IP=="+data.IP)
+			msg += t.I18nBot("tgbot.messages.time", "Time=="+data.Time)
+			return msg
+		}
+		return header + t.I18nBot("tgbot.messages.eventLoginFallback", "Source=="+e.Source)
+	}
+
+	return ""
+}

internal/web/service/tgbot/tgbot_inbound.go

@@ -0,0 +1,306 @@
+package tgbot
+
+import (
+	"errors"
+	"fmt"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/mhsanaei/3x-ui/v3/internal/database/model"
+	"github.com/mhsanaei/3x-ui/v3/internal/logger"
+	"github.com/mhsanaei/3x-ui/v3/internal/util/common"
+
+	"github.com/mymmrac/telego"
+	tu "github.com/mymmrac/telego/telegoutil"
+)
+
+// getInboundUsages retrieves and formats inbound usage information.
+func (t *Tgbot) getInboundUsages() string {
+	var info strings.Builder
+	inbounds, err := t.inboundService.GetAllInbounds()
+	if err != nil {
+		logger.Warning("GetAllInbounds run failed:", err)
+		info.WriteString(t.I18nBot("tgbot.answers.getInboundsFailed"))
+		return info.String()
+	}
+	for _, inbound := range inbounds {
+		info.WriteString(t.I18nBot("tgbot.messages.inbound", "Remark=="+inbound.Remark))
+		info.WriteString(t.I18nBot("tgbot.messages.port", "Port=="+strconv.Itoa(inbound.Port)))
+		info.WriteString(t.I18nBot("tgbot.messages.traffic", "Total=="+common.FormatTraffic((inbound.Up+inbound.Down)), "Upload=="+common.FormatTraffic(inbound.Up), "Download=="+common.FormatTraffic(inbound.Down)))
+
+		clients, listErr := t.clientService.ListForInbound(nil, inbound.Id)
+		if listErr == nil {
+			fmt.Fprintf(&info, "👥 Clients: %d\r\n", len(clients))
+		}
+
+		if inbound.ExpiryTime == 0 {
+			info.WriteString(t.I18nBot("tgbot.messages.expire", "Time=="+t.I18nBot("tgbot.unlimited")))
+		} else {
+			info.WriteString(t.I18nBot("tgbot.messages.expire", "Time=="+time.Unix((inbound.ExpiryTime/1000), 0).Format("2006-01-02 15:04:05")))
+		}
+		info.WriteString("\r\n")
+	}
+	return info.String()
+}
+
+// getInbounds creates an inline keyboard with all inbounds.
+func (t *Tgbot) getInbounds() (*telego.InlineKeyboardMarkup, error) {
+	inbounds, err := t.inboundService.GetAllInbounds()
+	if err != nil {
+		logger.Warning("GetAllInbounds run failed:", err)
+		return nil, errors.New(t.I18nBot("tgbot.answers.getInboundsFailed"))
+	}
+
+	if len(inbounds) == 0 {
+		logger.Warning("No inbounds found")
+		return nil, errors.New(t.I18nBot("tgbot.answers.getInboundsFailed"))
+	}
+
+	var buttons []telego.InlineKeyboardButton
+	for _, inbound := range inbounds {
+		status := "❌"
+		if inbound.Enable {
+			status = "✅"
+		}
+		callbackData := t.encodeQuery(fmt.Sprintf("%s %d", "get_clients", inbound.Id))
+		buttons = append(buttons, tu.InlineKeyboardButton(fmt.Sprintf("%v - %v", inbound.Remark, status)).WithCallbackData(callbackData))
+	}
+
+	cols := 1
+	if len(buttons) >= 6 {
+		cols = 2
+	}
+
+	keyboard := tu.InlineKeyboardGrid(tu.InlineKeyboardCols(cols, buttons...))
+	return keyboard, nil
+}
+
+// getInboundsFor builds an inline keyboard of inbounds for a custom next action.
+func (t *Tgbot) getInboundsFor(nextAction string) (*telego.InlineKeyboardMarkup, error) {
+	inbounds, err := t.inboundService.GetAllInbounds()
+	if err != nil {
+		logger.Warning("GetAllInbounds run failed:", err)
+		return nil, errors.New(t.I18nBot("tgbot.answers.getInboundsFailed"))
+	}
+
+	if len(inbounds) == 0 {
+		logger.Warning("No inbounds found")
+		return nil, errors.New(t.I18nBot("tgbot.answers.getInboundsFailed"))
+	}
+
+	var buttons []telego.InlineKeyboardButton
+	for _, inbound := range inbounds {
+		status := "❌"
+		if inbound.Enable {
+			status = "✅"
+		}
+		callbackData := t.encodeQuery(fmt.Sprintf("%s %d", nextAction, inbound.Id))
+		buttons = append(buttons, tu.InlineKeyboardButton(fmt.Sprintf("%v - %v", inbound.Remark, status)).WithCallbackData(callbackData))
+	}
+
+	cols := 1
+	if len(buttons) >= 6 {
+		cols = 2
+	}
+
+	keyboard := tu.InlineKeyboardGrid(tu.InlineKeyboardCols(cols, buttons...))
+	return keyboard, nil
+}
+
+// getInboundClientsFor lists clients of an inbound with a specific action prefix to be appended with email
+func (t *Tgbot) getInboundClientsFor(inboundID int, action string) (*telego.InlineKeyboardMarkup, error) {
+	inbound, err := t.inboundService.GetInbound(inboundID)
+	if err != nil {
+		logger.Warning("getInboundClientsFor run failed:", err)
+		return nil, errors.New(t.I18nBot("tgbot.answers.getInboundsFailed"))
+	}
+	clients, err := t.inboundService.GetClients(inbound)
+	var buttons []telego.InlineKeyboardButton
+
+	if err != nil {
+		logger.Warning("GetInboundClients run failed:", err)
+		return nil, errors.New(t.I18nBot("tgbot.answers.getInboundsFailed"))
+	} else {
+		if len(clients) > 0 {
+			for _, client := range clients {
+				buttons = append(buttons, tu.InlineKeyboardButton(client.Email).WithCallbackData(t.encodeQuery(action+" "+client.Email)))
+			}
+		} else {
+			return nil, errors.New(t.I18nBot("tgbot.answers.getClientsFailed"))
+		}
+	}
+	cols := 0
+	if len(buttons) < 6 {
+		cols = 3
+	} else {
+		cols = 2
+	}
+	keyboard := tu.InlineKeyboardGrid(tu.InlineKeyboardCols(cols, buttons...))
+
+	return keyboard, nil
+}
+
+// getInboundsAddClient creates an inline keyboard for adding clients to inbounds.
+func (t *Tgbot) getInboundsAddClient() (*telego.InlineKeyboardMarkup, error) {
+	inbounds, err := t.inboundService.GetAllInbounds()
+	if err != nil {
+		logger.Warning("GetAllInbounds run failed:", err)
+		return nil, errors.New(t.I18nBot("tgbot.answers.getInboundsFailed"))
+	}
+
+	if len(inbounds) == 0 {
+		logger.Warning("No inbounds found")
+		return nil, errors.New(t.I18nBot("tgbot.answers.getInboundsFailed"))
+	}
+
+	excludedProtocols := map[model.Protocol]bool{
+		model.Tunnel:    true,
+		model.Mixed:     true,
+		model.WireGuard: true,
+		model.AmneziaWG: true,
+		model.HTTP:      true,
+	}
+
+	var buttons []telego.InlineKeyboardButton
+	for _, inbound := range inbounds {
+		if excludedProtocols[inbound.Protocol] {
+			continue
+		}
+
+		status := "❌"
+		if inbound.Enable {
+			status = "✅"
+		}
+		callbackData := t.encodeQuery(fmt.Sprintf("%s %d", "add_client_to", inbound.Id))
+		buttons = append(buttons, tu.InlineKeyboardButton(fmt.Sprintf("%v - %v", inbound.Remark, status)).WithCallbackData(callbackData))
+	}
+
+	cols := 1
+	if len(buttons) >= 6 {
+		cols = 2
+	}
+
+	keyboard := tu.InlineKeyboardGrid(tu.InlineKeyboardCols(cols, buttons...))
+	return keyboard, nil
+}
+
+// getInboundsAttachPicker builds a toggle picker over multi-client inbounds
+// for the "attach more inbounds to the new client" step. Each row shows the
+// current selection state for the inbound; tapping fires
+// add_client_toggle_attach <id> which flips it and re-renders. A final
+// "Done" button (add_client_attach_done) returns to the field-edit screen.
+func (t *Tgbot) getInboundsAttachPicker() (*telego.InlineKeyboardMarkup, error) {
+	inbounds, err := t.inboundService.GetAllInbounds()
+	if err != nil {
+		logger.Warning("GetAllInbounds run failed:", err)
+		return nil, errors.New(t.I18nBot("tgbot.answers.getInboundsFailed"))
+	}
+	if len(inbounds) == 0 {
+		return nil, errors.New(t.I18nBot("tgbot.answers.getInboundsFailed"))
+	}
+	excludedProtocols := map[model.Protocol]bool{
+		model.Tunnel:    true,
+		model.Mixed:     true,
+		model.WireGuard: true,
+		model.AmneziaWG: true,
+		model.HTTP:      true,
+	}
+	selected := make(map[int]bool, len(receiver_inbound_IDs))
+	for _, id := range receiver_inbound_IDs {
+		selected[id] = true
+	}
+	var buttons []telego.InlineKeyboardButton
+	for _, ib := range inbounds {
+		if excludedProtocols[ib.Protocol] {
+			continue
+		}
+		mark := "☐"
+		if selected[ib.Id] {
+			mark = "✅"
+		}
+		label := fmt.Sprintf("%s %s (%s)", mark, ib.Remark, ib.Protocol)
+		callback := t.encodeQuery(fmt.Sprintf("add_client_toggle_attach %d", ib.Id))
+		buttons = append(buttons, tu.InlineKeyboardButton(label).WithCallbackData(callback))
+	}
+	cols := 1
+	if len(buttons) >= 6 {
+		cols = 2
+	}
+	rows := tu.InlineKeyboardCols(cols, buttons...)
+	rows = append(rows, tu.InlineKeyboardRow(
+		tu.InlineKeyboardButton("✅ Done").WithCallbackData(t.encodeQuery("add_client_attach_done")),
+	))
+	return tu.InlineKeyboardGrid(rows), nil
+}
+
+// getInboundClients creates an inline keyboard with clients of a specific inbound.
+func (t *Tgbot) getInboundClients(id int) (*telego.InlineKeyboardMarkup, error) {
+	inbound, err := t.inboundService.GetInbound(id)
+	if err != nil {
+		logger.Warning("getIboundClients run failed:", err)
+		return nil, errors.New(t.I18nBot("tgbot.answers.getInboundsFailed"))
+	}
+	clients, err := t.inboundService.GetClients(inbound)
+	var buttons []telego.InlineKeyboardButton
+
+	if err != nil {
+		logger.Warning("GetInboundClients run failed:", err)
+		return nil, errors.New(t.I18nBot("tgbot.answers.getInboundsFailed"))
+	} else {
+		if len(clients) > 0 {
+			for _, client := range clients {
+				buttons = append(buttons, tu.InlineKeyboardButton(client.Email).WithCallbackData(t.encodeQuery("client_get_usage "+client.Email)))
+			}
+		} else {
+			return nil, errors.New(t.I18nBot("tgbot.answers.getClientsFailed"))
+		}
+	}
+	cols := 0
+	if len(buttons) < 6 {
+		cols = 3
+	} else {
+		cols = 2
+	}
+	keyboard := tu.InlineKeyboardGrid(tu.InlineKeyboardCols(cols, buttons...))
+
+	return keyboard, nil
+}
+
+// searchInbound searches for inbounds by remark and sends the results.
+func (t *Tgbot) searchInbound(chatId int64, remark string) {
+	inbounds, err := t.inboundService.SearchInbounds(remark)
+	if err != nil {
+		logger.Warning(err)
+		msg := t.I18nBot("tgbot.wentWrong")
+		t.SendMsgToTgbot(chatId, msg)
+		return
+	}
+	if len(inbounds) == 0 {
+		msg := t.I18nBot("tgbot.noInbounds")
+		t.SendMsgToTgbot(chatId, msg)
+		return
+	}
+
+	for _, inbound := range inbounds {
+		info := ""
+		info += t.I18nBot("tgbot.messages.inbound", "Remark=="+inbound.Remark)
+		info += t.I18nBot("tgbot.messages.port", "Port=="+strconv.Itoa(inbound.Port))
+		info += t.I18nBot("tgbot.messages.traffic", "Total=="+common.FormatTraffic((inbound.Up+inbound.Down)), "Upload=="+common.FormatTraffic(inbound.Up), "Download=="+common.FormatTraffic(inbound.Down))
+
+		if inbound.ExpiryTime == 0 {
+			info += t.I18nBot("tgbot.messages.expire", "Time=="+t.I18nBot("tgbot.unlimited"))
+		} else {
+			info += t.I18nBot("tgbot.messages.expire", "Time=="+time.Unix((inbound.ExpiryTime/1000), 0).Format("2006-01-02 15:04:05"))
+		}
+		t.SendMsgToTgbot(chatId, info)
+
+		if len(inbound.ClientStats) > 0 {
+			var output strings.Builder
+			for _, traffic := range inbound.ClientStats {
+				output.WriteString(t.clientInfoMsg(&traffic, true, true, true, true, true, true))
+			}
+			t.SendMsgToTgbot(chatId, output.String())
+		}
+	}
+}

internal/web/service/tgbot/tgbot_report.go

@@ -0,0 +1,509 @@
+package tgbot
+
+import (
+	"context"
+	"fmt"
+	"net"
+	"os"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/mhsanaei/3x-ui/v3/internal/config"
+	"github.com/mhsanaei/3x-ui/v3/internal/database/model"
+	"github.com/mhsanaei/3x-ui/v3/internal/eventbus"
+	"github.com/mhsanaei/3x-ui/v3/internal/logger"
+	"github.com/mhsanaei/3x-ui/v3/internal/util/common"
+	"github.com/mhsanaei/3x-ui/v3/internal/web/service"
+	"github.com/mhsanaei/3x-ui/v3/internal/xray"
+
+	"github.com/mymmrac/telego"
+	tu "github.com/mymmrac/telego/telegoutil"
+)
+
+// SendReport sends a periodic report to admin chats.
+func (t *Tgbot) SendReport() {
+	runTime, err := t.settingService.GetTgbotRuntime()
+	if err == nil && len(runTime) > 0 {
+		msg := ""
+		msg += t.I18nBot("tgbot.messages.report", "RunTime=="+runTime)
+		msg += t.I18nBot("tgbot.messages.datetime", "DateTime=="+time.Now().Format("2006-01-02 15:04:05"))
+		t.SendMsgToTgbotAdmins(msg)
+	}
+
+	info := t.sendServerUsage()
+	t.SendMsgToTgbotAdmins(info)
+
+	t.sendExhaustedToAdmins()
+	t.notifyExhausted()
+
+	backupEnable, err := t.settingService.GetTgBotBackup()
+	if err == nil && backupEnable {
+		t.SendBackupToAdmins()
+	}
+}
+
+// SendBackupToAdmins sends a database backup to admin chats.
+func (t *Tgbot) SendBackupToAdmins() {
+	if !t.IsRunning() {
+		return
+	}
+	dbData, err := t.serverService.GetDb()
+	if err != nil {
+		logger.Error("Error in getting db backup: ", err)
+	}
+	dbFilename := t.serverService.BackupFilename("")
+	for i, adminId := range adminIds {
+		t.sendBackupData(adminId, dbData, dbFilename)
+		// Add delay between sends to avoid Telegram rate limits
+		if i < len(adminIds)-1 {
+			time.Sleep(1 * time.Second)
+		}
+	}
+}
+
+// sendExhaustedToAdmins sends notifications about exhausted clients to admins.
+func (t *Tgbot) sendExhaustedToAdmins() {
+	if !t.IsRunning() {
+		return
+	}
+	for _, adminId := range adminIds {
+		t.getExhausted(adminId)
+	}
+}
+
+// getServerUsage retrieves and formats server usage information.
+func (t *Tgbot) getServerUsage(chatId int64, messageID ...int) string {
+	info := t.prepareServerUsageInfo()
+
+	keyboard := tu.InlineKeyboard(tu.InlineKeyboardRow(
+		tu.InlineKeyboardButton(t.I18nBot("tgbot.buttons.refresh")).WithCallbackData(t.encodeQuery("usage_refresh"))))
+
+	if len(messageID) > 0 {
+		t.editMessageTgBot(chatId, messageID[0], info, keyboard)
+	} else {
+		t.SendMsgToTgbot(chatId, info, keyboard)
+	}
+
+	return info
+}
+
+// Send server usage without an inline keyboard
+func (t *Tgbot) sendServerUsage() string {
+	info := t.prepareServerUsageInfo()
+	return info
+}
+
+// prepareServerUsageInfo prepares the server usage information string.
+func (t *Tgbot) prepareServerUsageInfo() string {
+	// Check if we have cached data first
+	if cachedStats, found := t.getCachedServerStats(); found {
+		return cachedStats
+	}
+
+	info, ipv4, ipv6 := "", "", ""
+
+	// get latest status of server with caching
+	if cachedStatus, found := t.getCachedStatus(); found {
+		t.lastStatus = cachedStatus
+	} else {
+		t.lastStatus = t.serverService.GetStatus(t.lastStatus)
+		t.setCachedStatus(t.lastStatus)
+	}
+	var onlines []string
+	if process := service.XrayProcess(); process != nil {
+		onlines = process.GetOnlineClients()
+	}
+
+	info += t.I18nBot("tgbot.messages.hostname", "Hostname=="+hostname)
+	info += t.I18nBot("tgbot.messages.version", "Version=="+config.GetPanelVersion())
+	info += t.I18nBot("tgbot.messages.xrayVersion", "XrayVersion=="+fmt.Sprint(t.lastStatus.Xray.Version))
+
+	// get ip address
+	netInterfaces, err := net.Interfaces()
+	if err != nil {
+		logger.Error("net.Interfaces failed, err: ", err.Error())
+		info += t.I18nBot("tgbot.messages.ip", "IP=="+t.I18nBot("tgbot.unknown"))
+		info += "\r\n"
+	} else {
+		for i := range netInterfaces {
+			if (netInterfaces[i].Flags & net.FlagUp) != 0 {
+				addrs, _ := netInterfaces[i].Addrs()
+
+				for _, address := range addrs {
+					if ipnet, ok := address.(*net.IPNet); ok && !ipnet.IP.IsLoopback() {
+						if ipnet.IP.To4() != nil {
+							ipv4 += ipnet.IP.String() + " "
+						} else if ipnet.IP.To16() != nil && !ipnet.IP.IsLinkLocalUnicast() {
+							ipv6 += ipnet.IP.String() + " "
+						}
+					}
+				}
+			}
+		}
+
+		info += t.I18nBot("tgbot.messages.ipv4", "IPv4=="+ipv4)
+		info += t.I18nBot("tgbot.messages.ipv6", "IPv6=="+ipv6)
+	}
+
+	info += t.I18nBot("tgbot.messages.serverUpTime", "UpTime=="+strconv.FormatUint(t.lastStatus.Uptime/86400, 10), "Unit=="+t.I18nBot("tgbot.days"))
+	info += t.I18nBot("tgbot.messages.serverLoad", "Load1=="+strconv.FormatFloat(t.lastStatus.Loads[0], 'f', 2, 64), "Load2=="+strconv.FormatFloat(t.lastStatus.Loads[1], 'f', 2, 64), "Load3=="+strconv.FormatFloat(t.lastStatus.Loads[2], 'f', 2, 64))
+	info += t.I18nBot("tgbot.messages.serverMemory", "Current=="+common.FormatTraffic(int64(t.lastStatus.Mem.Current)), "Total=="+common.FormatTraffic(int64(t.lastStatus.Mem.Total)))
+	info += t.I18nBot("tgbot.messages.onlinesCount", "Count=="+fmt.Sprint(len(onlines)))
+	info += t.I18nBot("tgbot.messages.tcpCount", "Count=="+strconv.Itoa(t.lastStatus.TcpCount))
+	info += t.I18nBot("tgbot.messages.udpCount", "Count=="+strconv.Itoa(t.lastStatus.UdpCount))
+	info += t.I18nBot("tgbot.messages.traffic", "Total=="+common.FormatTraffic(int64(t.lastStatus.NetTraffic.Sent+t.lastStatus.NetTraffic.Recv)), "Upload=="+common.FormatTraffic(int64(t.lastStatus.NetTraffic.Sent)), "Download=="+common.FormatTraffic(int64(t.lastStatus.NetTraffic.Recv)))
+	info += t.I18nBot("tgbot.messages.xrayStatus", "State=="+fmt.Sprint(t.lastStatus.Xray.State))
+
+	// Cache the complete server stats
+	t.setCachedServerStats(info)
+
+	return info
+}
+
+// UserLoginNotify publishes a login event to the event bus.
+func (t *Tgbot) UserLoginNotify(attempt LoginAttempt) {
+	if attempt.Username == "" || attempt.IP == "" || attempt.Time == "" {
+		logger.Warning("UserLoginNotify failed, invalid info!")
+		return
+	}
+
+	if EventBus == nil {
+		return
+	}
+
+	status := "fail"
+	if attempt.Status == LoginSuccess {
+		status = "success"
+	}
+
+	EventBus.Publish(eventbus.Event{
+		Type:   eventbus.EventLoginAttempt,
+		Source: attempt.IP,
+		Data: &eventbus.LoginEventData{
+			Username: attempt.Username,
+			IP:       attempt.IP,
+			Time:     attempt.Time,
+			Status:   status,
+			Reason:   attempt.Reason,
+		},
+	})
+}
+
+// getExhausted retrieves and sends information about exhausted clients.
+func (t *Tgbot) getExhausted(chatId int64) {
+	trDiff := int64(0)
+	exDiff := int64(0)
+	now := time.Now().Unix() * 1000
+	var exhaustedInbounds []model.Inbound
+	var exhaustedClients []xray.ClientTraffic
+	var disabledInbounds []model.Inbound
+	var disabledClients []xray.ClientTraffic
+
+	TrafficThreshold, err := t.settingService.GetTrafficDiff()
+	if err == nil && TrafficThreshold > 0 {
+		trDiff = int64(TrafficThreshold) * 1073741824
+	}
+	ExpireThreshold, err := t.settingService.GetExpireDiff()
+	if err == nil && ExpireThreshold > 0 {
+		exDiff = int64(ExpireThreshold) * 86400000
+	}
+	inbounds, err := t.inboundService.GetAllInbounds()
+	if err != nil {
+		logger.Warning("Unable to load Inbounds", err)
+	}
+
+	seenClients := make(map[string]bool)
+	for _, inbound := range inbounds {
+		if inbound.Enable {
+			if (inbound.ExpiryTime > 0 && (inbound.ExpiryTime-now < exDiff)) ||
+				(inbound.Total > 0 && (inbound.Total-(inbound.Up+inbound.Down) < trDiff)) {
+				exhaustedInbounds = append(exhaustedInbounds, *inbound)
+			}
+			if len(inbound.ClientStats) > 0 {
+				for _, client := range inbound.ClientStats {
+					if seenClients[client.Email] {
+						continue
+					}
+					seenClients[client.Email] = true
+					if client.Enable {
+						if (client.ExpiryTime > 0 && (client.ExpiryTime-now < exDiff)) ||
+							(client.Total > 0 && (client.Total-(client.Up+client.Down) < trDiff)) {
+							exhaustedClients = append(exhaustedClients, client)
+						}
+					} else {
+						disabledClients = append(disabledClients, client)
+					}
+				}
+			}
+		} else {
+			disabledInbounds = append(disabledInbounds, *inbound)
+		}
+	}
+
+	// Inbounds
+	output := ""
+	output += t.I18nBot("tgbot.messages.exhaustedCount", "Type=="+t.I18nBot("tgbot.inbounds"))
+	output += t.I18nBot("tgbot.messages.disabled", "Disabled=="+strconv.Itoa(len(disabledInbounds)))
+	output += t.I18nBot("tgbot.messages.depleteSoon", "Deplete=="+strconv.Itoa(len(exhaustedInbounds)))
+
+	if len(exhaustedInbounds) > 0 {
+		output += t.I18nBot("tgbot.messages.depleteSoon", "Deplete=="+t.I18nBot("tgbot.inbounds"))
+
+		for _, inbound := range exhaustedInbounds {
+			output += t.I18nBot("tgbot.messages.inbound", "Remark=="+inbound.Remark)
+			output += t.I18nBot("tgbot.messages.port", "Port=="+strconv.Itoa(inbound.Port))
+			output += t.I18nBot("tgbot.messages.traffic", "Total=="+common.FormatTraffic((inbound.Up+inbound.Down)), "Upload=="+common.FormatTraffic(inbound.Up), "Download=="+common.FormatTraffic(inbound.Down))
+			if inbound.ExpiryTime == 0 {
+				output += t.I18nBot("tgbot.messages.expire", "Time=="+t.I18nBot("tgbot.unlimited"))
+			} else {
+				output += t.I18nBot("tgbot.messages.expire", "Time=="+time.Unix((inbound.ExpiryTime/1000), 0).Format("2006-01-02 15:04:05"))
+			}
+			output += "\r\n"
+		}
+	}
+
+	// Clients
+	exhaustedCC := len(exhaustedClients)
+	output += t.I18nBot("tgbot.messages.exhaustedCount", "Type=="+t.I18nBot("tgbot.clients"))
+	output += t.I18nBot("tgbot.messages.disabled", "Disabled=="+strconv.Itoa(len(disabledClients)))
+	output += t.I18nBot("tgbot.messages.depleteSoon", "Deplete=="+strconv.Itoa(exhaustedCC))
+
+	if exhaustedCC > 0 {
+		output += t.I18nBot("tgbot.messages.depleteSoon", "Deplete=="+t.I18nBot("tgbot.clients"))
+		var buttons []telego.InlineKeyboardButton
+		for _, traffic := range exhaustedClients {
+			output += t.clientInfoMsg(&traffic, true, false, false, true, true, false)
+			output += "\r\n"
+			buttons = append(buttons, tu.InlineKeyboardButton(traffic.Email).WithCallbackData(t.encodeQuery("client_get_usage "+traffic.Email)))
+		}
+		cols := 0
+		if exhaustedCC < 11 {
+			cols = 1
+		} else {
+			cols = 2
+		}
+		output += t.I18nBot("tgbot.messages.refreshedOn", "Time=="+time.Now().Format("2006-01-02 15:04:05"))
+		keyboard := tu.InlineKeyboardGrid(tu.InlineKeyboardCols(cols, buttons...))
+		t.SendMsgToTgbot(chatId, output, keyboard)
+	} else {
+		output += t.I18nBot("tgbot.messages.refreshedOn", "Time=="+time.Now().Format("2006-01-02 15:04:05"))
+		t.SendMsgToTgbot(chatId, output)
+	}
+}
+
+// notifyExhausted sends notifications for exhausted clients.
+func (t *Tgbot) notifyExhausted() {
+	trDiff := int64(0)
+	exDiff := int64(0)
+	now := time.Now().Unix() * 1000
+
+	TrafficThreshold, err := t.settingService.GetTrafficDiff()
+	if err == nil && TrafficThreshold > 0 {
+		trDiff = int64(TrafficThreshold) * 1073741824
+	}
+	ExpireThreshold, err := t.settingService.GetExpireDiff()
+	if err == nil && ExpireThreshold > 0 {
+		exDiff = int64(ExpireThreshold) * 86400000
+	}
+	inbounds, err := t.inboundService.GetAllInbounds()
+	if err != nil {
+		logger.Warning("Unable to load Inbounds", err)
+	}
+
+	var chatIDsDone []int64
+	for _, inbound := range inbounds {
+		if inbound.Enable {
+			if len(inbound.ClientStats) > 0 {
+				clients, err := t.inboundService.GetClients(inbound)
+				if err == nil {
+					for _, client := range clients {
+						if client.TgID != 0 {
+							chatID := client.TgID
+							if !int64Contains(chatIDsDone, chatID) && !checkAdmin(chatID) {
+								var disabledClients []xray.ClientTraffic
+								var exhaustedClients []xray.ClientTraffic
+								traffics, err := t.inboundService.GetClientTrafficTgBot(client.TgID)
+								if err == nil && len(traffics) > 0 {
+									var output strings.Builder
+									output.WriteString(t.I18nBot("tgbot.messages.exhaustedCount", "Type=="+t.I18nBot("tgbot.clients")))
+									for _, traffic := range traffics {
+										if traffic.Enable {
+											if (traffic.ExpiryTime > 0 && (traffic.ExpiryTime-now < exDiff)) ||
+												(traffic.Total > 0 && (traffic.Total-(traffic.Up+traffic.Down) < trDiff)) {
+												exhaustedClients = append(exhaustedClients, *traffic)
+											}
+										} else {
+											disabledClients = append(disabledClients, *traffic)
+										}
+									}
+									if len(exhaustedClients) > 0 {
+										output.WriteString(t.I18nBot("tgbot.messages.disabled", "Disabled=="+strconv.Itoa(len(disabledClients))))
+										if len(disabledClients) > 0 {
+											output.WriteString(t.I18nBot("tgbot.clients"))
+											output.WriteString(":\r\n")
+											for _, traffic := range disabledClients {
+												output.WriteString(" ")
+												output.WriteString(traffic.Email)
+											}
+											output.WriteString("\r\n")
+										}
+										output.WriteString("\r\n")
+										output.WriteString(t.I18nBot("tgbot.messages.depleteSoon", "Deplete=="+strconv.Itoa(len(exhaustedClients))))
+										for _, traffic := range exhaustedClients {
+											output.WriteString(t.clientInfoMsg(&traffic, true, false, false, true, true, false))
+											output.WriteString("\r\n")
+										}
+										t.SendMsgToTgbot(chatID, output.String())
+									}
+									chatIDsDone = append(chatIDsDone, chatID)
+								}
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+}
+
+// onlineClients retrieves and sends information about online clients.
+func (t *Tgbot) onlineClients(chatId int64, messageID ...int) {
+	process := service.XrayProcess()
+	if process == nil || !process.IsRunning() {
+		return
+	}
+
+	onlines := process.GetOnlineClients()
+	onlinesCount := len(onlines)
+	output := t.I18nBot("tgbot.messages.onlinesCount", "Count=="+fmt.Sprint(onlinesCount))
+	keyboard := tu.InlineKeyboard(tu.InlineKeyboardRow(
+		tu.InlineKeyboardButton(t.I18nBot("tgbot.buttons.refresh")).WithCallbackData(t.encodeQuery("onlines_refresh"))))
+
+	if onlinesCount > 0 {
+		var buttons []telego.InlineKeyboardButton
+		for _, online := range onlines {
+			label := online
+			if _, inbound, err := t.inboundService.GetClientInboundByEmail(online); err == nil && inbound != nil && inbound.Remark != "" {
+				label = online + " - " + inbound.Remark
+			}
+			buttons = append(buttons, tu.InlineKeyboardButton(label).WithCallbackData(t.encodeQuery("client_get_usage "+online)))
+		}
+		cols := 0
+		if onlinesCount < 21 {
+			cols = 2
+		} else if onlinesCount < 61 {
+			cols = 3
+		} else {
+			cols = 4
+		}
+		keyboard.InlineKeyboard = append(keyboard.InlineKeyboard, tu.InlineKeyboardCols(cols, buttons...)...)
+	}
+
+	if len(messageID) > 0 {
+		t.editMessageTgBot(chatId, messageID[0], output, keyboard)
+	} else {
+		t.SendMsgToTgbot(chatId, output, keyboard)
+	}
+}
+
+// sendBackup sends a backup of the database and configuration files.
+func (t *Tgbot) sendBackup(chatId int64) {
+	dbData, err := t.serverService.GetDb()
+	if err != nil {
+		logger.Error("Error in getting db backup: ", err)
+	}
+	t.sendBackupData(chatId, dbData, t.serverService.BackupFilename(""))
+}
+
+func (t *Tgbot) sendBackupData(chatId int64, dbData []byte, dbFilename string) {
+	output := t.I18nBot("tgbot.messages.hostname", "Hostname=="+hostname)
+	output += t.I18nBot("tgbot.messages.backupTime", "Time=="+time.Now().Format("2006-01-02 15:04:05"))
+	t.SendMsgToTgbot(chatId, output)
+
+	// Send database backup (SQLite file, or a pg_dump archive on PostgreSQL)
+	if dbData != nil {
+		ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
+		document := tu.Document(
+			tu.ID(chatId),
+			tu.FileFromBytes(dbData, dbFilename),
+		)
+		_, err := bot.SendDocument(ctx, document)
+		cancel()
+		if err != nil {
+			logger.Error("Error in uploading backup: ", err)
+		}
+	}
+
+	// Small delay between file sends
+	time.Sleep(500 * time.Millisecond)
+
+	// Send config.json backup
+	file, err := os.Open(xray.GetConfigPath())
+	if err == nil {
+		defer file.Close()
+		ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
+		defer cancel()
+		document := tu.Document(
+			tu.ID(chatId),
+			tu.File(file),
+		)
+		_, err = bot.SendDocument(ctx, document)
+		if err != nil {
+			logger.Error("Error in uploading config.json: ", err)
+		}
+	} else {
+		logger.Error("Error in opening config.json file for backup: ", err)
+	}
+}
+
+// sendBanLogs sends the ban logs to the specified chat.
+func (t *Tgbot) sendBanLogs(chatId int64, dt bool) {
+	if dt {
+		output := t.I18nBot("tgbot.messages.hostname", "Hostname=="+hostname)
+		output += t.I18nBot("tgbot.messages.datetime", "DateTime=="+time.Now().Format("2006-01-02 15:04:05"))
+		t.SendMsgToTgbot(chatId, output)
+	}
+
+	file, err := os.Open(xray.GetIPLimitBannedPrevLogPath())
+	if err == nil {
+		// Check if the file is non-empty before attempting to upload
+		fileInfo, _ := file.Stat()
+		if fileInfo.Size() > 0 {
+			document := tu.Document(
+				tu.ID(chatId),
+				tu.File(file),
+			)
+			_, err = bot.SendDocument(context.Background(), document)
+			if err != nil {
+				logger.Error("Error in uploading IPLimitBannedPrevLog: ", err)
+			}
+		} else {
+			logger.Warning("IPLimitBannedPrevLog file is empty, not uploading.")
+		}
+		file.Close()
+	} else {
+		logger.Error("Error in opening IPLimitBannedPrevLog file for backup: ", err)
+	}
+
+	file, err = os.Open(xray.GetIPLimitBannedLogPath())
+	if err == nil {
+		// Check if the file is non-empty before attempting to upload
+		fileInfo, _ := file.Stat()
+		if fileInfo.Size() > 0 {
+			document := tu.Document(
+				tu.ID(chatId),
+				tu.File(file),
+			)
+			_, err = bot.SendDocument(context.Background(), document)
+			if err != nil {
+				logger.Error("Error in uploading IPLimitBannedLog: ", err)
+			}
+		} else {
+			logger.Warning("IPLimitBannedLog file is empty, not uploading.")
+		}
+		file.Close()
+	} else {
+		logger.Error("Error in opening IPLimitBannedLog file for backup: ", err)
+	}
+}

internal/web/service/tgbot/tgbot_send.go

@@ -0,0 +1,296 @@
+package tgbot
+
+import (
+	"context"
+	"fmt"
+	"strings"
+	"time"
+
+	"github.com/mhsanaei/3x-ui/v3/internal/logger"
+
+	"github.com/mymmrac/telego"
+	tu "github.com/mymmrac/telego/telegoutil"
+)
+
+// sendResponse sends the response message based on the onlyMessage flag.
+func (t *Tgbot) sendResponse(chatId int64, msg string, onlyMessage, isAdmin bool) {
+	if onlyMessage {
+		t.SendMsgToTgbot(chatId, msg)
+	} else {
+		t.SendAnswer(chatId, msg, isAdmin)
+	}
+}
+
+// SendAnswer sends a response message with an inline keyboard to the specified chat.
+func (t *Tgbot) SendAnswer(chatId int64, msg string, isAdmin bool) {
+	numericKeyboard := tu.InlineKeyboard(
+		tu.InlineKeyboardRow(
+			tu.InlineKeyboardButton(t.I18nBot("tgbot.buttons.SortedTrafficUsageReport")).WithCallbackData(t.encodeQuery("get_sorted_traffic_usage_report")),
+		),
+		tu.InlineKeyboardRow(
+			tu.InlineKeyboardButton(t.I18nBot("tgbot.buttons.serverUsage")).WithCallbackData(t.encodeQuery("get_usage")),
+			tu.InlineKeyboardButton(t.I18nBot("tgbot.buttons.ResetAllTraffics")).WithCallbackData(t.encodeQuery("reset_all_traffics")),
+		),
+		tu.InlineKeyboardRow(
+			tu.InlineKeyboardButton(t.I18nBot("tgbot.buttons.dbBackup")).WithCallbackData(t.encodeQuery("get_backup")),
+			tu.InlineKeyboardButton(t.I18nBot("tgbot.buttons.getBanLogs")).WithCallbackData(t.encodeQuery("get_banlogs")),
+		),
+		tu.InlineKeyboardRow(
+			tu.InlineKeyboardButton(t.I18nBot("tgbot.buttons.getInbounds")).WithCallbackData(t.encodeQuery("inbounds")),
+			tu.InlineKeyboardButton(t.I18nBot("tgbot.buttons.depleteSoon")).WithCallbackData(t.encodeQuery("deplete_soon")),
+		),
+		tu.InlineKeyboardRow(
+			tu.InlineKeyboardButton(t.I18nBot("tgbot.buttons.commands")).WithCallbackData(t.encodeQuery("commands")),
+			tu.InlineKeyboardButton(t.I18nBot("tgbot.buttons.onlines")).WithCallbackData(t.encodeQuery("onlines")),
+		),
+		tu.InlineKeyboardRow(
+			tu.InlineKeyboardButton(t.I18nBot("tgbot.buttons.allClients")).WithCallbackData(t.encodeQuery("get_inbounds")),
+			tu.InlineKeyboardButton(t.I18nBot("tgbot.buttons.addClient")).WithCallbackData(t.encodeQuery("add_client")),
+		),
+		tu.InlineKeyboardRow(
+			tu.InlineKeyboardButton(t.I18nBot("pages.settings.subSettings")).WithCallbackData(t.encodeQuery("admin_client_sub_links")),
+			tu.InlineKeyboardButton(t.I18nBot("subscription.individualLinks")).WithCallbackData(t.encodeQuery("admin_client_individual_links")),
+			tu.InlineKeyboardButton(t.I18nBot("qrCode")).WithCallbackData(t.encodeQuery("admin_client_qr_links")),
+		),
+		// TODOOOOOOOOOOOOOO: Add restart button here.
+	)
+	numericKeyboardClient := tu.InlineKeyboard(
+		tu.InlineKeyboardRow(
+			tu.InlineKeyboardButton(t.I18nBot("tgbot.buttons.clientUsage")).WithCallbackData(t.encodeQuery("client_traffic")),
+			tu.InlineKeyboardButton(t.I18nBot("tgbot.buttons.commands")).WithCallbackData(t.encodeQuery("client_commands")),
+		),
+		tu.InlineKeyboardRow(
+			tu.InlineKeyboardButton(t.I18nBot("pages.settings.subSettings")).WithCallbackData(t.encodeQuery("client_sub_links")),
+			tu.InlineKeyboardButton(t.I18nBot("subscription.individualLinks")).WithCallbackData(t.encodeQuery("client_individual_links")),
+		),
+		tu.InlineKeyboardRow(
+			tu.InlineKeyboardButton(t.I18nBot("qrCode")).WithCallbackData(t.encodeQuery("client_qr_links")),
+		),
+	)
+
+	var ReplyMarkup telego.ReplyMarkup
+	if isAdmin {
+		ReplyMarkup = numericKeyboard
+	} else {
+		ReplyMarkup = numericKeyboardClient
+	}
+	t.SendMsgToTgbot(chatId, msg, ReplyMarkup)
+}
+
+const telegramPageLimit = 2000
+
+func pageMessage(message string, limit int) []string {
+	if len(message) <= limit {
+		return []string{message}
+	}
+
+	pages := make([]string, 0)
+	for _, block := range strings.Split(message, "\r\n\r\n") {
+		for _, page := range splitMessageLines(block, limit) {
+			last := len(pages) - 1
+			if last >= 0 && len(pages[last])+len("\r\n\r\n")+len(page) <= limit {
+				pages[last] += "\r\n\r\n" + page
+				continue
+			}
+			pages = append(pages, page)
+		}
+	}
+	if len(pages) > 0 && strings.TrimSpace(pages[len(pages)-1]) == "" {
+		pages = pages[:len(pages)-1]
+	}
+	return pages
+}
+
+func splitMessageLines(block string, limit int) []string {
+	if len(block) <= limit {
+		return []string{block}
+	}
+
+	lines := strings.Split(block, "\r\n")
+	pages := []string{lines[0]}
+	for _, line := range lines[1:] {
+		last := len(pages) - 1
+		if len(pages[last])+len("\r\n")+len(line) > limit {
+			pages = append(pages, line)
+			continue
+		}
+		pages[last] += "\r\n" + line
+	}
+	return pages
+}
+
+// SendMsgToTgbot sends a message to the Telegram bot with optional reply markup.
+func (t *Tgbot) SendMsgToTgbot(chatId int64, msg string, replyMarkup ...telego.ReplyMarkup) {
+	if !isRunning {
+		return
+	}
+
+	if msg == "" {
+		logger.Info("[tgbot] message is empty!")
+		return
+	}
+
+	allMessages := pageMessage(msg, telegramPageLimit)
+	for n, message := range allMessages {
+		params := telego.SendMessageParams{
+			ChatID:    tu.ID(chatId),
+			Text:      message,
+			ParseMode: "HTML",
+		}
+		// only add replyMarkup to last message
+		if len(replyMarkup) > 0 && n == (len(allMessages)-1) {
+			params.ReplyMarkup = replyMarkup[0]
+		}
+
+		// Retry logic with exponential backoff for connection errors
+		maxRetries := 3
+		for attempt := range maxRetries {
+			ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
+			_, err := bot.SendMessage(ctx, &params)
+			cancel()
+
+			if err == nil {
+				break // Success
+			}
+
+			// Check if error is a connection error
+			errStr := err.Error()
+			isConnectionError := strings.Contains(errStr, "connection") ||
+				strings.Contains(errStr, "timeout") ||
+				strings.Contains(errStr, "closed")
+
+			if isConnectionError && attempt < maxRetries-1 {
+				// Exponential backoff: 1s, 2s, 4s
+				backoff := time.Duration(1<<uint(attempt)) * time.Second
+				logger.Warningf("Connection error sending telegram message (attempt %d/%d), retrying in %v: %v",
+					attempt+1, maxRetries, backoff, err)
+				time.Sleep(backoff)
+			} else {
+				logger.Warning("Error sending telegram message:", err)
+				break
+			}
+		}
+
+		// Reduced delay to improve performance (only needed for rate limiting)
+		if n < len(allMessages)-1 { // Only delay between messages, not after the last one
+			time.Sleep(100 * time.Millisecond)
+		}
+	}
+}
+
+// SendMsgToTgbotAdmins sends a message to all admin Telegram chats.
+func (t *Tgbot) SendMsgToTgbotAdmins(msg string, replyMarkup ...telego.ReplyMarkup) {
+	if len(replyMarkup) > 0 {
+		for _, adminId := range adminIds {
+			t.SendMsgToTgbot(adminId, msg, replyMarkup[0])
+		}
+	} else {
+		for _, adminId := range adminIds {
+			t.SendMsgToTgbot(adminId, msg)
+		}
+	}
+}
+
+// sendCallbackAnswerTgBot answers a callback query with a message.
+func (t *Tgbot) sendCallbackAnswerTgBot(id string, message string) {
+	params := telego.AnswerCallbackQueryParams{
+		CallbackQueryID: id,
+		Text:            message,
+	}
+	if err := bot.AnswerCallbackQuery(context.Background(), &params); err != nil {
+		logger.Warning(err)
+	}
+}
+
+// editMessageCallbackTgBot edits the reply markup of a message.
+func (t *Tgbot) editMessageCallbackTgBot(chatId int64, messageID int, inlineKeyboard *telego.InlineKeyboardMarkup) {
+	params := telego.EditMessageReplyMarkupParams{
+		ChatID:      tu.ID(chatId),
+		MessageID:   messageID,
+		ReplyMarkup: inlineKeyboard,
+	}
+	if _, err := bot.EditMessageReplyMarkup(context.Background(), &params); err != nil {
+		logger.Warning(err)
+	}
+}
+
+// editMessageTgBot edits the text and reply markup of a message.
+func (t *Tgbot) editMessageTgBot(chatId int64, messageID int, text string, inlineKeyboard ...*telego.InlineKeyboardMarkup) {
+	params := telego.EditMessageTextParams{
+		ChatID:    tu.ID(chatId),
+		MessageID: messageID,
+		Text:      text,
+		ParseMode: "HTML",
+	}
+	if len(inlineKeyboard) > 0 {
+		params.ReplyMarkup = inlineKeyboard[0]
+	}
+	if _, err := bot.EditMessageText(context.Background(), &params); err != nil {
+		logger.Warning(err)
+	}
+}
+
+// SendMsgToTgbotDeleteAfter sends a message and deletes it after a specified delay.
+func (t *Tgbot) SendMsgToTgbotDeleteAfter(chatId int64, msg string, delayInSeconds int, replyMarkup ...telego.ReplyMarkup) {
+	// Determine if replyMarkup was passed; otherwise, set it to nil
+	var replyMarkupParam telego.ReplyMarkup
+	if len(replyMarkup) > 0 {
+		replyMarkupParam = replyMarkup[0] // Use the first element
+	}
+
+	// Send the message
+	sentMsg, err := bot.SendMessage(context.Background(), &telego.SendMessageParams{
+		ChatID:      tu.ID(chatId),
+		Text:        msg,
+		ReplyMarkup: replyMarkupParam, // Use the correct replyMarkup value
+	})
+	if err != nil {
+		logger.Warning("Failed to send message:", err)
+		return
+	}
+
+	// Delete the sent message after the specified number of seconds.
+	go t.deleteMessageAfterDelay(chatId, sentMsg.MessageID, delayInSeconds)
+}
+
+// deleteMessageAfterDelay waits delayInSeconds and then removes the message. It
+// deliberately does not touch the conversation state: every caller that ends a
+// wizard step already clears the state synchronously, and clearing it here — up
+// to several seconds later — would wipe a state the user set for the next step
+// in the meantime, silently dropping their following input.
+func (t *Tgbot) deleteMessageAfterDelay(chatId int64, messageID, delayInSeconds int) {
+	time.Sleep(time.Duration(delayInSeconds) * time.Second)
+	t.deleteMessageTgBot(chatId, messageID)
+}
+
+// deleteMessageTgBot deletes a message from the chat.
+func (t *Tgbot) deleteMessageTgBot(chatId int64, messageID int) {
+	if bot == nil {
+		return
+	}
+	params := telego.DeleteMessageParams{
+		ChatID:    tu.ID(chatId),
+		MessageID: messageID,
+	}
+	if err := bot.DeleteMessage(context.Background(), &params); err != nil {
+		logger.Warning("Failed to delete message:", err)
+	} else {
+		logger.Info("Message deleted successfully")
+	}
+}
+
+// TestConnection verifies the bot token is valid and the API is reachable.
+func (t *Tgbot) TestConnection() error {
+	tgBotMutex.Lock()
+	b := bot
+	tgBotMutex.Unlock()
+	if b == nil {
+		return fmt.Errorf("bot not initialized")
+	}
+	me, err := b.GetMe(context.Background())
+	if err != nil {
+		return fmt.Errorf("API unreachable: %w", err)
+	}
+	_ = me
+	return nil
+}

internal/web/service/tgbot/tgbot_send_test.go

@@ -0,0 +1,35 @@
+package tgbot
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestPageMessageSplitsLinkListWithoutBlankLines(t *testing.T) {
+	var message strings.Builder
+	message.WriteString("Individual links:\r\n")
+	for range 50 {
+		message.WriteString("<code>vless://" + strings.Repeat("a", 300) + "</code>\r\n")
+	}
+
+	pages := pageMessage(message.String(), telegramPageLimit)
+	if len(pages) < 2 {
+		t.Fatalf("pageMessage() returned %d page, want multiple", len(pages))
+	}
+
+	links := 0
+	for index, page := range pages {
+		if len(page) > telegramPageLimit {
+			t.Errorf("page %d has %d bytes, want at most %d", index, len(page), telegramPageLimit)
+		}
+		openingTags := strings.Count(page, "<code>")
+		closingTags := strings.Count(page, "</code>")
+		if openingTags != closingTags {
+			t.Errorf("page %d has %d opening tags and %d closing tags", index, openingTags, closingTags)
+		}
+		links += openingTags
+	}
+	if links != 50 {
+		t.Errorf("pages contain %d links, want 50", links)
+	}
+}

internal/web/service/tgbot/tgbot_test.go

@@ -0,0 +1,125 @@
+package tgbot
+
+import (
+	"io"
+	"net"
+	"reflect"
+	"testing"
+	"time"
+)
+
+func TestLoginAttemptDoesNotCarryPassword(t *testing.T) {
+	typ := reflect.TypeFor[LoginAttempt]()
+	if _, ok := typ.FieldByName("Password"); ok {
+		t.Fatal("LoginAttempt must not carry attempted passwords")
+	}
+}
+
+func TestIsSupportedBotProxyScheme(t *testing.T) {
+	supported := []string{
+		"socks5://127.0.0.1:1080",
+		"http://127.0.0.1:8080",
+		"https://127.0.0.1:8080",
+	}
+	for _, p := range supported {
+		if !isSupportedBotProxyScheme(p) {
+			t.Errorf("expected %q to be supported", p)
+		}
+	}
+	unsupported := []string{"", "ftp://x", "127.0.0.1:1080", "socks4://1.2.3.4:1080"}
+	for _, p := range unsupported {
+		if isSupportedBotProxyScheme(p) {
+			t.Errorf("expected %q to be unsupported", p)
+		}
+	}
+}
+
+func recordingDialTarget(t *testing.T, n int) (addr string, got chan []byte) {
+	t.Helper()
+	ln, err := net.Listen("tcp", "127.0.0.1:0")
+	if err != nil {
+		t.Fatal(err)
+	}
+	got = make(chan []byte, 1)
+	t.Cleanup(func() { _ = ln.Close() })
+	go func() {
+		conn, err := ln.Accept()
+		if err != nil {
+			return
+		}
+		defer conn.Close()
+		_ = conn.SetReadDeadline(time.Now().Add(2 * time.Second))
+		buf := make([]byte, n)
+		m, _ := io.ReadFull(conn, buf)
+		got <- buf[:m]
+	}()
+	return ln.Addr().String(), got
+}
+
+func TestTgbotProxyDialerSelectsHTTPForHTTPScheme(t *testing.T) {
+	addr, got := recordingDialTarget(t, len("CONNECT "))
+	tg := &Tgbot{}
+	client := tg.createRobustFastHTTPClient("http://" + addr)
+	if client.Dial == nil {
+		t.Fatal("Dial must be set for an http:// proxy")
+	}
+	go func() { _, _ = client.Dial("example.com:443") }()
+	select {
+	case b := <-got:
+		if string(b) != "CONNECT " {
+			t.Fatalf("expected HTTP CONNECT to the proxy, got %q", b)
+		}
+	case <-time.After(3 * time.Second):
+		t.Fatal("proxy never received a connection")
+	}
+}
+
+func TestTgbotProxyDialerSelectsSOCKSForSocks5Scheme(t *testing.T) {
+	addr, got := recordingDialTarget(t, 1)
+	tg := &Tgbot{}
+	client := tg.createRobustFastHTTPClient("socks5://" + addr)
+	if client.Dial == nil {
+		t.Fatal("Dial must be set for a socks5:// proxy")
+	}
+	go func() { _, _ = client.Dial("example.com:443") }()
+	select {
+	case b := <-got:
+		if len(b) != 1 || b[0] != 0x05 {
+			t.Fatalf("expected SOCKS5 greeting (0x05), got %v", b)
+		}
+	case <-time.After(3 * time.Second):
+		t.Fatal("proxy never received a connection")
+	}
+}
+
+func TestTgbotProxyDialerNoneWhenEmpty(t *testing.T) {
+	tg := &Tgbot{}
+	client := tg.createRobustFastHTTPClient("")
+	if client.Dial != nil {
+		t.Fatal("Dial must be nil when no proxy is configured")
+	}
+}
+
+func TestIsCommandForBotAllowsUntargetedCommand(t *testing.T) {
+	if !isCommandForBot("/status", "panel_bot") {
+		t.Fatal("untargeted commands must remain accepted")
+	}
+}
+
+func TestIsCommandForBotAllowsMatchingUsername(t *testing.T) {
+	if !isCommandForBot("/status@panel_bot", "Panel_Bot") {
+		t.Fatal("commands targeted to this bot must be accepted")
+	}
+}
+
+func TestIsCommandForBotRejectsOtherUsername(t *testing.T) {
+	if isCommandForBot("/status@other_bot", "panel_bot") {
+		t.Fatal("commands targeted to another bot must be ignored")
+	}
+}
+
+func TestIsCommandForBotKeepsLegacyBehaviorWhenUsernameUnavailable(t *testing.T) {
+	if !isCommandForBot("/status@panel_bot", "") {
+		t.Fatal("commands must remain accepted when the current bot username is unavailable")
+	}
+}