Crash hotfix for the ANNOYING PALOCHKA fix

Fix the annoying PALOCHKA
Support reply ID accounting for SFS uploads
2026-08-05 12:17:06 +00:00 · 2026-06-20 12:57:27 -04:00 · 2026-06-04 20:04:35 -04:00 · 2026-06-02 21:48:59 -04:00 · 2025-10-31 13:16:56 -04:00 · 2025-10-27 18:21:49 -04:00
15 changed files with 1204 additions and 376 deletions
--- a/2
+++ b/2
@ -2,7 +2,7 @@

 COMMIT := $(shell git rev-parse --short HEAD)
 TD_COMMIT := "5bbfc1cf5dab94f82e02f3430ded7241d4653551"
-VERSION := "v1.10.1"
+VERSION := "v1.12.8"
 MAKEOPTS := "-j4"

 all:
--- a/persistence/sessions.go
+++ b/persistence/sessions.go
@ -51,7 +51,13 @@ type Session struct {
 	IgnoreGroupDeletions bool `yaml:":ignoregroupdeletions"`
 }

-var configKeys = []string{
+const (
+	PropertyTypeUnknown byte = iota
+	PropertyTypeString
+	PropertyTypeBool
+)
+
+var ConfigKeys = []string{
 	"timezone",
 	"keeponline",
 	"rawmessages",
@ -181,7 +187,7 @@ func (s *Session) ToMap() map[string]string {
 	defer sessionsLock.Unlock()

 	m := make(map[string]string)
-	for _, configKey := range configKeys {
+	for _, configKey := range ConfigKeys {
 		value, _ := s.get(configKey)
 		m[configKey] = value
 	}
@ -266,6 +272,18 @@ func (s *Session) Set(key string, value string) (string, error) {
 	return "", errors.New("Unknown session property")
 }

+// PropertyType determines the property type
+func PropertyType(key string) byte {
+	switch key {
+	case "timezone":
+		return PropertyTypeString
+	case "keeponline", "rawmessages", "asciiarrows", "oobmode", "carbons", "hideids",
+		"receipts", "nativeedits", "ignoregroupdeletions":
+		return PropertyTypeBool
+	}
+	return PropertyTypeUnknown
+}
+
 // TimezoneToLocation tries to convert config timezone to location
 func (s *Session) TimezoneToLocation() *time.Location {
 	time, err := time.Parse("-07:00", s.Timezone)
--- a/telegabber.go
+++ b/telegabber.go
@ -16,7 +16,7 @@ import (
 	goxmpp "gosrc.io/xmpp"
 )

-var version string = "1.10.1"
+var version string = "1.12.8"
 var commit string

 var sm *goxmpp.StreamManager
@ -68,7 +68,7 @@ func main() {

 	log.Infof("Starting telegabber version %v", version)

-	sm, component, err = xmpp.NewComponent(config.XMPP, config.Telegram, *idsPath)
+	sm, component, err = xmpp.NewComponent(config.XMPP, config.Telegram, *idsPath, version)
 	if err != nil {
 		log.Fatal(err)
 	}
--- a/telegram/cache/cache.go
+++ b/telegram/cache/cache.go
@ -16,7 +16,8 @@ type Status struct {
 // Cache allows operating the chats and users cache in
 // a thread-safe manner
 type Cache struct {
-	chats        map[int64]*client.Chat
+	ownChats     map[int64]*client.Chat
+	auxChats     map[int64]*client.Chat
 	users        map[int64]*client.User
 	statuses     map[int64]*Status
 	chatsLock    sync.Mutex
@ -27,7 +28,8 @@ type Cache struct {
 // NewCache initializes a cache
 func NewCache() *Cache {
 	return &Cache{
-		chats:    map[int64]*client.Chat{},
+		ownChats: map[int64]*client.Chat{},
+		auxChats: map[int64]*client.Chat{},
 		users:    map[int64]*client.User{},
 		statuses: map[int64]*Status{},
 	}
@ -40,7 +42,23 @@ func (cache *Cache) ChatsKeys() []int64 {
 	defer cache.chatsLock.Unlock()

 	var keys []int64
-	for id := range cache.chats {
+	for id := range cache.ownChats {
+		keys = append(keys, id)
+	}
+	for id := range cache.auxChats {
+		keys = append(keys, id)
+	}
+	return keys
+}
+
+// OwnChatsKeys grabs only own chat ids synchronously to avoid lockups
+// while they are used
+func (cache *Cache) OwnChatsKeys() []int64 {
+	cache.chatsLock.Lock()
+	defer cache.chatsLock.Unlock()
+
+	var keys []int64
+	for id := range cache.ownChats {
 		keys = append(keys, id)
 	}
 	return keys
@ -84,7 +102,10 @@ func (cache *Cache) GetChat(id int64) (*client.Chat, bool) {
 	cache.chatsLock.Lock()
 	defer cache.chatsLock.Unlock()

-	chat, ok := cache.chats[id]
+	chat, ok := cache.ownChats[id]
+	if !ok {
+		chat, ok = cache.auxChats[id]
+	}
 	return chat, ok
 }

@ -107,11 +128,21 @@ func (cache *Cache) GetStatus(id int64) (*Status, bool) {
 }

 // SetChat stores a chat in the cache
-func (cache *Cache) SetChat(id int64, chat *client.Chat) {
+func (cache *Cache) SetChat(id int64, chat *client.Chat, own bool) {
 	cache.chatsLock.Lock()
 	defer cache.chatsLock.Unlock()

-	cache.chats[id] = chat
+	if own {
+		cache.ownChats[id] = chat
+		// move from aux to own, but not vice versa
+		// (own: true means that presences for the chat are needed
+		// for sure, false means just "not necessarily")
+		if _, ok := cache.auxChats[id]; ok {
+			delete(cache.auxChats, id)
+		}
+	} else {
+		cache.auxChats[id] = chat
+	}
 }

 // SetUser stores a user in the cache
--- a/telegram/client.go
+++ b/telegram/client.go
@ -2,7 +2,6 @@ package telegram

 import (
 	"github.com/pkg/errors"
-	"hash/maphash"
 	"path/filepath"
 	"strconv"
 	"sync"
@ -28,6 +27,41 @@ type HashedAvatar struct {
 	File int32
 }

+// NewId stores message ids and timestamps of their additions so old ones can be truncated to save memory
+type newId struct {
+	Id      int64
+	Ts      int64
+	lock    sync.Mutex
+	ownLock sync.Mutex
+	locked  bool
+	fired   bool
+}
+
+func newNewId() *newId {
+	return &newId{Ts: time.Now().Unix()}
+}
+
+func (i *newId) Lock() {
+	i.ownLock.Lock()
+	if i.fired {
+		i.ownLock.Unlock()
+		return
+	}
+	i.locked = true
+	i.ownLock.Unlock()
+	i.lock.Lock()
+}
+
+func (i *newId) Unlock() {
+	i.ownLock.Lock()
+	if i.locked {
+		i.lock.Unlock()
+		i.locked = false
+		i.fired = true
+	}
+	i.ownLock.Unlock()
+}
+
 // Client stores the metadata for lazily invoked TDlib instance
 type Client struct {
 	client     *client.Client
@ -44,6 +78,10 @@ type Client struct {
 	cache     *cache.Cache
 	online    bool

+	loginWizard *loginWizardMetadata
+
+	lastAuthorizationStateType string
+
 	outbox     map[string]string
 	editOutbox map[string]string

@ -52,7 +90,8 @@ type Client struct {

 	lastMsgHashes map[int64]uint64
 	lastMsgIds    map[int64]string
-	msgHashSeed   maphash.Seed
+
+	LastBotCmdString string

 	XmppClientFeatures     map[string]*[]string
 	XmppClientFeaturesLock sync.Mutex
@ -60,6 +99,9 @@ type Client struct {
 	AvatarHashes     map[int64]*HashedAvatar
 	AvatarHashesLock sync.Mutex

+	MessageIdChanges     map[int64]map[int64]*newId
+	MessageIdChangesLock sync.Mutex
+
 	locks           clientLocks
 	SendMessageLock sync.Mutex
 }
@ -75,6 +117,15 @@ type clientLocks struct {

 	authorizerReadLock  sync.Mutex
 	authorizerWriteLock sync.Mutex
+
+	loginWizardReadLock  sync.Mutex
+	loginWizardWriteLock sync.Mutex
+}
+
+type loginWizardMetadata struct {
+	nextStage   chan string
+	chanBusy    bool
+	commandSent bool
 }

 // NewClient instantiates a Telegram App
@ -134,9 +185,9 @@ func NewClient(conf config.TelegramConfig, jid string, component *xmpp.Component
 		DelayedStatuses:    make(map[int64]*DelayedStatus),
 		lastMsgHashes:      make(map[int64]uint64),
 		lastMsgIds:         make(map[int64]string),
-		msgHashSeed:        maphash.MakeSeed(),
 		XmppClientFeatures: make(map[string]*[]string),
 		AvatarHashes:       make(map[int64]*HashedAvatar),
+		MessageIdChanges:   make(map[int64]map[int64]*newId),
 		locks: clientLocks{
 			chatMessageLocks: make(map[int64]*sync.Mutex),
 		},
--- a/telegram/commands.go
+++ b/telegram/commands.go
@ -9,6 +9,7 @@ import (
 	"time"
 	"unicode"

+	"dev.narayana.im/narayana/telegabber/persistence"
 	"dev.narayana.im/narayana/telegabber/xmpp/gateway"

 	log "github.com/sirupsen/logrus"
@ -50,22 +51,23 @@ var permissionsMember = client.ChatPermissions{
 var permissionsReadonly = client.ChatPermissions{}

 var transportCommands = map[string]command{
-	"help":        command{0, []string{}, "help", nil},
-	"login":       command{1, []string{"phone"}, "sign in", nil},
-	"logout":      command{0, []string{}, "sign out", nil},
-	"cancelauth":  command{0, []string{}, "quit the signin wizard", nil},
-	"code":        command{1, []string{"xxxxx"}, "check one-time code", nil},
-	"password":    command{1, []string{"********"}, "check 2fa password", nil},
-	"setusername": command{0, []string{"@username"}, "update @username", nil},
-	"setname":     command{1, []string{"first", "last"}, "update name", nil},
-	"setbio":      command{0, []string{"Lorem ipsum"}, "update about", nil},
-	"setpassword": command{0, []string{"old", "new"}, "set or remove password", nil},
-	"config":      command{0, []string{"param", "value"}, "view or update configuration options", nil},
-	"report":      command{2, []string{"chat", "comment"}, "report a chat by id or @username", nil},
-	"add":         command{1, []string{"@username"}, "add @username to your chat list", nil},
-	"join":        command{1, []string{"https://t.me/invite_link"}, "join to chat via invite link or @publicname", nil},
-	"supergroup":  command{1, []string{"title", "description"}, "create new supergroup «title» with «description»", nil},
-	"channel":     command{1, []string{"title", "description"}, "create new channel «title» with «description»", nil},
+	"help":        command{0, []string{}, "help", false, nil, false},
+	"login":       command{1, []string{"phone"}, "sign in", false, nil, false},
+	"logout":      command{0, []string{}, "sign out", true, nil, true},
+	"cleanup":     command{0, []string{}, "unsubscribe from all known chats", false, nil, false},
+	"cancelauth":  command{0, []string{}, "quit the signin wizard", false, nil, false},
+	"code":        command{1, []string{"xxxxx"}, "check one-time code", false, nil, false},
+	"password":    command{1, []string{"********"}, "check 2fa password", false, nil, false},
+	"setusername": command{0, []string{"@username"}, "update @username", true, nil, true},
+	"setname":     command{1, []string{"first", "last"}, "update name", true, nil, false},
+	"setbio":      command{0, []string{"Lorem ipsum"}, "update about", true, nil, true},
+	"setpassword": command{0, []string{"old", "new"}, "set or remove password", true, nil, true},
+	"config":      command{0, []string{"param", "value"}, "view or update configuration options", false, nil, false},
+	"report":      command{2, []string{"chat", "comment"}, "report a chat by id or @username", true, nil, true},
+	"add":         command{1, []string{"@username"}, "add @username to your chat list", true, nil, true},
+	"join":        command{1, []string{"https://t.me/invite_link"}, "join to chat via invite link or @publicname", true, nil, true},
+	"supergroup":  command{1, []string{"title", "description"}, "create new supergroup «title» with «description»", true, nil, true},
+	"channel":     command{1, []string{"title", "description"}, "create new channel «title» with «description»", true, nil, true},
 }

 var notForGroups = []ChatType{ChatTypeBasicGroup, ChatTypeSupergroup, ChatTypeChannel}
@ -74,50 +76,60 @@ var notForPMAndBasic = []ChatType{ChatTypePrivate, ChatTypeSecret, ChatTypeBasic
 var onlyForSecret = []ChatType{ChatTypePrivate, ChatTypeBasicGroup, ChatTypeSupergroup, ChatTypeChannel}

 var chatCommands = map[string]command{
-	"help":       command{0, []string{}, "help", nil},
-	"d":          command{0, []string{"n"}, "delete your last message(s)", nil},
-	"s":          command{1, []string{"edited message"}, "edit your last message", nil},
-	"silent":     command{1, []string{"message"}, "send a message without sound", nil},
-	"schedule":   command{2, []string{"{online | 2006-01-02T15:04:05 | 15:04:05}", "message"}, "schedules a message either to timestamp or to whenever the user goes online", nil},
-	"forward":    command{2, []string{"message_id", "target_chat"}, "forwards a message", nil},
-	"vcard":      command{0, []string{}, "print vCard as text", nil},
-	"add":        command{1, []string{"@username"}, "add @username to your chat list", nil},
-	"join":       command{1, []string{"https://t.me/invite_link"}, "join to chat via invite link or @publicname", nil},
-	"group":      command{1, []string{"title"}, "create groupchat «title» with current user", &notForGroups},
-	"supergroup": command{1, []string{"title", "description"}, "create new supergroup «title» with «description»", nil},
-	"channel":    command{1, []string{"title", "description"}, "create new channel «title» with «description»", nil},
-	"secret":     command{0, []string{}, "create secretchat with current user", &notForGroups},
-	"search":     command{0, []string{"string", "[limit]"}, "search <string> in current chat", nil},
-	"history":    command{0, []string{"limit"}, "get last [limit] messages from current chat", nil},
-	"block":      command{0, []string{}, "blacklist current user", &notForGroups},
-	"unblock":    command{0, []string{}, "unblacklist current user", &notForGroups},
-	"invite":     command{1, []string{"id or @username"}, "add user to current chat", &notForPM},
-	"link":       command{0, []string{}, "get invite link for current chat", &notForPM},
-	"kick":       command{1, []string{"id or @username"}, "remove user from current chat", &notForPM},
-	"mute":       command{0, []string{"id or @username", "hours"}, "mute the whole chat or a user in current chat", &notForPMAndBasic},
-	"unmute":     command{0, []string{"id or @username"}, "unmute the whole chat or a user in the current chat", &notForPMAndBasic},
-	"ban":        command{1, []string{"id or @username", "hours"}, "restrict @username from current chat for [hours] or forever", &notForPM},
-	"unban":      command{1, []string{"id or @username"}, "unbans @username in current chat (and devotes from admins)", &notForPM},
-	"promote":    command{1, []string{"id or @username", "title"}, "promote user to admin in current chat", &notForPM},
-	"leave":      command{0, []string{}, "leave current chat", &notForPM},
-	"leave!":     command{0, []string{}, "leave current chat (for owners)", &notForPM},
-	"ttl":        command{0, []string{"seconds"}, "set secret chat messages TTL before self-destroying", &onlyForSecret},
-	"close":      command{0, []string{}, "close current secret chat", &onlyForSecret},
-	"delete":     command{0, []string{}, "delete current chat from chat list", nil},
-	"members":    command{0, []string{"query"}, "search members [by optional query] in current chat (requires admin rights)", nil},
+	"help":       command{0, []string{}, "help", false, nil, false},
+	"d":          command{0, []string{"n"}, "delete your last message(s)", true, nil, true},
+	"s":          command{1, []string{"edited message"}, "edit your last message", true, nil, true},
+	"silent":     command{1, []string{"message"}, "send a message without sound", true, nil, true},
+	"schedule":   command{2, []string{"{online | 2006-01-02T15:04:05 | 15:04:05}", "message"}, "schedules a message either to timestamp or to whenever the user goes online", true, nil, true},
+	"raw":        command{1, []string{"message"}, "send a raw message not interpeted as a transport command (e.g. a bot command)", true, nil, true},
+	"forward":    command{2, []string{"message_id", "target_chat"}, "forwards a message", true, nil, true},
+	"vcard":      command{0, []string{}, "print vCard as text", true, nil, true},
+	"add":        command{1, []string{"@username"}, "add @username to your chat list", true, nil, true},
+	"join":       command{1, []string{"https://t.me/invite_link"}, "join to chat via invite link or @publicname", true, nil, true},
+	"group":      command{1, []string{"title"}, "create groupchat «title» with current user", true, &notForGroups, true},
+	"supergroup": command{1, []string{"title", "description"}, "create new supergroup «title» with «description»", true, nil, true},
+	"channel":    command{1, []string{"title", "description"}, "create new channel «title» with «description»", true, nil, true},
+	"secret":     command{0, []string{}, "create secretchat with current user", true, &notForGroups, true},
+	"search":     command{0, []string{"string", "[limit]"}, "search <string> in current chat", true, nil, true},
+	"history":    command{0, []string{"limit"}, "get last [limit] messages from current chat", true, nil, true},
+	"block":      command{0, []string{}, "blacklist current user", true, &notForGroups, true},
+	"unblock":    command{0, []string{}, "unblacklist current user", true, &notForGroups, true},
+	"invite":     command{1, []string{"id or @username"}, "add user to current chat", true, &notForPM, true},
+	"link":       command{0, []string{}, "get invite link for current chat", true, &notForPM, true},
+	"kick":       command{1, []string{"id or @username"}, "remove user from current chat", true, &notForPM, true},
+	"mute":       command{0, []string{"id or @username", "hours"}, "mute the whole chat or a user in current chat", true, &notForPMAndBasic, true},
+	"unmute":     command{0, []string{"id or @username"}, "unmute the whole chat or a user in the current chat", true, &notForPMAndBasic, true},
+	"ban":        command{1, []string{"id or @username", "hours"}, "restrict @username from current chat for [hours] or forever", true, &notForPM, true},
+	"unban":      command{1, []string{"id or @username"}, "unbans @username in current chat (and devotes from admins)", true, &notForPM, true},
+	"promote":    command{1, []string{"id or @username", "title"}, "promote user to admin in current chat", true, &notForPM, true},
+	"leave":      command{0, []string{}, "leave current chat", true, &notForPM, true},
+	"leave!":     command{0, []string{}, "leave current chat (for owners)", true, &notForPM, true},
+	"ttl":        command{0, []string{"seconds"}, "set secret chat messages TTL before self-destroying", true, &onlyForSecret, true},
+	"close":      command{0, []string{}, "close current secret chat", true, &onlyForSecret, true},
+	"delete":     command{0, []string{}, "delete current chat from chat list", true, nil, true},
+	"members":    command{0, []string{"query"}, "search members [by optional query] in current chat (requires admin rights)", true, nil, true},
 }

 var transportConfigurationOptions = map[string]configurationOption{
 	"timezone":             configurationOption{"<timezone>", "adjust timezone for Telegram user statuses (example: +02:00)"},
-	"keeponline":  configurationOption{"<bool>", "always keep telegram session online and rely on jabber offline messages (example: true)"},
-	"rawmessages": configurationOption{"<bool>", "do not add additional info (message id, origin etc.) to incoming messages (example: true)"},
+	"keeponline":           configurationOption{"<bool>", "always keep telegram session online and rely on jabber offline messages (true/false)"},
+	"rawmessages":          configurationOption{"<bool>", "do not add additional info (message id, origin etc.) to incoming messages (true/false)"},
+	"asciiarrows":          configurationOption{"<bool>", "replace some Unicode symbols with ASCII alternatives for better compatibility (true/false)"},
+	"oobmode":              configurationOption{"<bool>", "use XEP-0066 (OOB); pros: some modern clients won't show images without it, cons: very restricted, Tkabber would flood with popups (true/false)"},
+	"carbons":              configurationOption{"<bool>", "send carbons to your another clients, will turn on only if supported by the server (true/false)"},
+	"hideids":              configurationOption{"<bool>", "hide message IDs from message info (true/false)"},
+	"receipts":             configurationOption{"<bool>", "if enabled, XMPP read receipts are synced to Telegram, otherwise, messages are marked as read automatically (true/false)"},
+	"nativeedits":          configurationOption{"<bool>", "if possible, edit XMPP messages instead of showing Telegram edits as separate messages (true/false)"},
+	"ignoregroupdeletions": configurationOption{"<bool>", "suppress message deletion messages in group chats (true/false)"},
 }

 type command struct {
 	RequiredArgs int
 	Arguments    []string
 	Description  string
+	LoginOnly    bool
 	NotFor       *[]ChatType
+	OnlineOnly   bool
 }
 type configurationOption struct {
 	arguments   string
@ -132,6 +144,15 @@ const (
 	CommandTypeChat
 )

+// OnlineFilter is a tri-state condition for commands selection
+type OnlineFilter int
+
+const (
+	OnlineFilterOnline OnlineFilter = iota
+	OnlineFilterNotOnline
+	OnlineFilterAny
+)
+
 // GetCommands exposes the set of commands
 func GetCommands(typ CommandType) map[string]command {
 	var commandMap map[string]command
@ -154,14 +175,20 @@ func GetCommand(typ CommandType, cmd string) (command, bool) {
 }

 // SortedCommandKeys sorts a slice with command keys
-func SortedCommandKeys(commandMap map[string]command) []string {
+func SortedCommandKeys(commandMap map[string]command, onlineFilter OnlineFilter) []string {
 	keys := make([]string, len(commandMap))

 	i := 0
 	for k := range commandMap {
+		command := commandMap[k]
+		if (onlineFilter == OnlineFilterOnline && !command.OnlineOnly) || (onlineFilter == OnlineFilterNotOnline && command.OnlineOnly) {
+			continue
+		}
+
 		keys[i] = k
 		i++
 	}
+	keys = keys[:i]

 	sort.Strings(keys)

@ -204,25 +231,34 @@ func IsCommandForChatType(cmd command, chatType ChatType) bool {
 	return true
 }

-func (c *Client) helpString(typ CommandType, chatId int64) string {
-	var str strings.Builder
-
-	commandMap := GetCommands(typ)
-	chatType, chatTypeErr := c.GetChatType(chatId)
-
-	str.WriteString("Available commands:\n")
-	for _, name := range SortedCommandKeys(commandMap) {
+func commandsToHelpString(str *strings.Builder, chatType ChatType, onlineFilter OnlineFilter, commandMap map[string]command) {
+	for _, name := range SortedCommandKeys(commandMap, onlineFilter) {
 		command := commandMap[name]
-		if chatTypeErr == nil && !IsCommandForChatType(command, chatType) {
+		if !IsCommandForChatType(command, chatType) {
 			continue
 		}
 		str.WriteString(CommandToHelpString(name, command))
 		str.WriteString("\n")
 	}
+}
+
+func (c *Client) helpString(typ CommandType, chatId int64) string {
+	var str strings.Builder
+
+	commandMap := GetCommands(typ)
+	chatType, _ := c.GetChatType(chatId, true)
+
+	str.WriteString("Available commands:\n")

 	if typ == CommandTypeTransport {
-		str.WriteString("Configuration options\n")
-		for name, option := range transportConfigurationOptions {
+		commandsToHelpString(&str, chatType, OnlineFilterNotOnline, commandMap)
+
+		str.WriteString("\nOnline-only commands:\n")
+		commandsToHelpString(&str, chatType, OnlineFilterOnline, commandMap)
+
+		str.WriteString("\nConfiguration options\n")
+		for _, name := range persistence.ConfigKeys {
+			option := transportConfigurationOptions[name]
 			str.WriteString(name)
 			str.WriteString(" ")
 			str.WriteString(option.arguments)
@ -230,6 +266,8 @@ func (c *Client) helpString(typ CommandType, chatId int64) string {
 			str.WriteString(option.description)
 			str.WriteString("\n")
 		}
+	} else if typ == CommandTypeChat {
+		commandsToHelpString(&str, chatType, OnlineFilterAny, commandMap)
 	}
 	str.WriteString("\nYou may use ! instead of / if it conflicts with internal commands of a client")

@ -268,6 +306,12 @@ func (c *Client) unsubscribe(chatID int64) error {
 	return c.sendPresence(args...)
 }

+func (c *Client) unsubscribeFromAll() {
+	for _, id := range c.cache.ChatsKeys() {
+		c.unsubscribe(id)
+	}
+}
+
 func (c *Client) sendMessagesReverse(chatID int64, messages []*client.Message) {
 	for i := len(messages) - 1; i >= 0; i-- {
 		message := messages[i]
@ -318,6 +362,9 @@ func (c *Client) ProcessTransportCommand(cmdline string, resource string) (strin
 	if len(args) < command.RequiredArgs {
 		return notEnoughArguments, false
 	}
+	if command.OnlineOnly && !c.Online() {
+		return notOnline, false
+	}

 	switch cmd {
 	case "login", "code", "password":
@ -356,22 +403,20 @@ func (c *Client) ProcessTransportCommand(cmdline string, resource string) (strin
 				c.authorizer.Password <- args[0]
 			}
 		}
+		return "", true
 	// sign out
 	case "logout":
-		if !c.Online() {
-			return notOnline, false
-		}
-
 		_, err := c.client.LogOut()
 		if err != nil {
 			return errors.Wrap(err, "Logout error").Error(), false
 		}

-		for _, id := range c.cache.ChatsKeys() {
-			c.unsubscribe(id)
-		}
+		c.unsubscribeFromAll()

 		c.Session.Login = ""
+	// cleanup
+	case "cleanup":
+		c.unsubscribeFromAll()
 	// cancel auth
 	case "cancelauth":
 		if c.Online() {
@ -381,10 +426,6 @@ func (c *Client) ProcessTransportCommand(cmdline string, resource string) (strin
 		return "Cancelled", true
 	// set @username
 	case "setusername":
-		if !c.Online() {
-			return notOnline, false
-		}
-
 		var username string
 		if len(args) > 0 {
 			username = args[0]
@ -429,10 +470,6 @@ func (c *Client) ProcessTransportCommand(cmdline string, resource string) (strin
 		}
 	// set About
 	case "setbio":
-		if !c.Online() {
-			return notOnline, false
-		}
-
 		_, err := c.client.SetBio(&client.SetBioRequest{
 			Bio: rawCmdArguments(cmdline, 0),
 		})
@ -441,15 +478,12 @@ func (c *Client) ProcessTransportCommand(cmdline string, resource string) (strin
 		}
 	// set password
 	case "setpassword":
-		if !c.Online() {
-			return notOnline, false
-		}
-
 		var oldPassword string
 		var newPassword string
-		// 0 or 1 argument is ignored and the password is reset
-		if len(args) > 1 {
+		if len(args) > 0 {
 			oldPassword = args[0]
+		}
+		if len(args) > 1 {
 			newPassword = args[1]
 		}
 		_, err := c.client.SetPassword(&client.SetPasswordRequest{
@ -461,7 +495,6 @@ func (c *Client) ProcessTransportCommand(cmdline string, resource string) (strin
 		}
 	case "config":
 		if len(args) > 1 {
-			var msg string
 			if gateway.MessageOutgoingPermissionVersion == 0 && args[0] == "carbons" && args[1] == "true" {
 				return "The server did not allow to enable carbons", false
 			}
@ -472,7 +505,7 @@ func (c *Client) ProcessTransportCommand(cmdline string, resource string) (strin
 			}
 			gateway.DirtySessions = true

-			return fmt.Sprintf("%s%s set to %s", msg, args[0], value), true
+			return fmt.Sprintf("%s set to %s", args[0], value), true
 		} else if len(args) > 0 {
 			value, err := c.Session.Get(args[0])
 			if err != nil {
@ -483,13 +516,18 @@ func (c *Client) ProcessTransportCommand(cmdline string, resource string) (strin
 		}

 		var entries []string
-		for key, value := range c.Session.ToMap() {
+		for _, key := range persistence.ConfigKeys {
+			value, err := c.Session.Get(key)
+			if err != nil {
+				log.Errorf("Achtung! Programming error in sessions with key %v", key)
+				continue
+			}
 			entries = append(entries, fmt.Sprintf("%s is set to %s", key, value))
 		}

 		return strings.Join(entries, "\n"), true
 	case "report":
-		contact, _, err := c.GetContactByUsername(args[0])
+		contact, _, err := c.GetContactByUsername(args[0], false)
 		if err != nil {
 			return err.Error(), false
 		}
@ -526,10 +564,6 @@ func (c *Client) ProcessTransportCommand(cmdline string, resource string) (strin
 // ProcessChatCommand executes a command sent in a mapped chat
 // and returns a response, the status of command support and the execution success result
 func (c *Client) ProcessChatCommand(chatID int64, cmdline string) (string, bool, bool) {
-	if !c.Online() {
-		return notOnline, true, false
-	}
-
 	cmd, args := parseCommand(cmdline)
 	command, ok := chatCommands[cmd]
 	if !ok {
@ -538,8 +572,12 @@ func (c *Client) ProcessChatCommand(chatID int64, cmdline string) (string, bool,
 	if len(args) < command.RequiredArgs {
 		return notEnoughArguments, true, false
 	}
+	if command.OnlineOnly && !c.Online() {
+		return notOnline, true, false
+	}

-	chatType, chatTypeErr := c.GetChatType(chatID)
+
+	chatType, chatTypeErr := c.GetChatType(chatID, true)
 	if chatTypeErr == nil && !IsCommandForChatType(command, chatType) {
 		return "Not applicable for this chat type", true, false
 	}
@ -583,6 +621,7 @@ func (c *Client) ProcessChatCommand(chatID int64, cmdline string) (string, bool,
 		if err != nil {
 			return err.Error(), true, false
 		}
+		return "", true, true
 	// edit message
 	case "s":
 		if c.me == nil {
@ -616,6 +655,7 @@ func (c *Client) ProcessChatCommand(chatID int64, cmdline string) (string, bool,
 		} else {
 			return "Message processing error", true, false
 		}
+		return "", true, true
 	// send without sound
 	case "silent":
 		content := c.PrepareOutgoingMessageContent(rawCmdArguments(cmdline, 0))
@ -643,11 +683,7 @@ func (c *Client) ProcessChatCommand(chatID int64, cmdline string) (string, bool,
 			state = &client.MessageSchedulingStateSendWhenOnline{}
 			result = due
 		} else {
-			if c.Session.Timezone == "" {
-				due += "Z"
-			} else {
-				due += c.Session.Timezone
-			}
+			due += c.GetTZD()

 			switch 0 {
 			default:
@ -710,6 +746,22 @@ func (c *Client) ProcessChatCommand(chatID int64, cmdline string) (string, bool,
 		} else {
 			return "Message processing error", true, false
 		}
+	// sends a raw non-interpreted message
+	case "raw":
+		content := c.PrepareOutgoingMessageContent(rawCmdArguments(cmdline, 0))
+
+		if content != nil {
+			_, err := c.client.SendMessage(&client.SendMessageRequest{
+				ChatId:              chatID,
+				InputMessageContent: content,
+			})
+			if err != nil {
+				return err.Error(), true, false
+			}
+		} else {
+			return "Message processing error", true, false
+		}
+		return "", true, true
 	// forward a message to chat
 	case "forward":
 		messageId, err := strconv.ParseInt(args[0], 10, 64)
@ -804,7 +856,7 @@ func (c *Client) ProcessChatCommand(chatID int64, cmdline string) (string, bool,
 		}
 	// invite @username to current groupchat
 	case "invite":
-		contact, _, err := c.GetContactByUsername(args[0])
+		contact, _, err := c.GetContactByUsername(args[0], false)
 		if err != nil {
 			return err.Error(), true, false
 		}
@ -831,7 +883,7 @@ func (c *Client) ProcessChatCommand(chatID int64, cmdline string) (string, bool,
 		return link.InviteLink, true, true
 	// kick @username from current group chat
 	case "kick":
-		contact, _, err := c.GetContactByUsername(args[0])
+		contact, _, err := c.GetContactByUsername(args[0], false)
 		if err != nil {
 			return err.Error(), true, false
 		}
@ -850,7 +902,7 @@ func (c *Client) ProcessChatCommand(chatID int64, cmdline string) (string, bool,
 	// mute [@username [n hours]]
 	case "mute":
 		if len(args) > 0 {
-			contact, _, err := c.GetContactByUsername(args[0])
+			contact, _, err := c.GetContactByUsername(args[0], false)
 			if err != nil {
 				return err.Error(), true, false
 			}
@ -887,7 +939,7 @@ func (c *Client) ProcessChatCommand(chatID int64, cmdline string) (string, bool,
 	// unmute [@username]
 	case "unmute":
 		if len(args) > 0 {
-			contact, _, err := c.GetContactByUsername(args[0])
+			contact, _, err := c.GetContactByUsername(args[0], false)
 			if err != nil {
 				return err.Error(), true, false
 			}
@ -915,7 +967,7 @@ func (c *Client) ProcessChatCommand(chatID int64, cmdline string) (string, bool,
 		}
 	// ban @username from current chat [for N hours]
 	case "ban":
-		contact, _, err := c.GetContactByUsername(args[0])
+		contact, _, err := c.GetContactByUsername(args[0], false)
 		if err != nil {
 			return err.Error(), true, false
 		}
@ -943,7 +995,7 @@ func (c *Client) ProcessChatCommand(chatID int64, cmdline string) (string, bool,
 		}
 	// unban @username
 	case "unban":
-		contact, _, err := c.GetContactByUsername(args[0])
+		contact, _, err := c.GetContactByUsername(args[0], false)
 		if err != nil {
 			return err.Error(), true, false
 		}
@ -961,7 +1013,7 @@ func (c *Client) ProcessChatCommand(chatID int64, cmdline string) (string, bool,
 		}
 	// promote @username to admin
 	case "promote":
-		contact, _, err := c.GetContactByUsername(args[0])
+		contact, _, err := c.GetContactByUsername(args[0], false)
 		if err != nil {
 			return err.Error(), true, false
 		}
@ -1033,7 +1085,7 @@ func (c *Client) ProcessChatCommand(chatID int64, cmdline string) (string, bool,
 		}
 	// close secret chat
 	case "close":
-		chat, _, err := c.GetContactByID(chatID, nil)
+		chat, _, err := c.GetContactByID(chatID, nil, true)
 		if err != nil {
 			return err.Error(), true, false
 		}
@ -1092,6 +1144,7 @@ func (c *Client) ProcessChatCommand(chatID int64, cmdline string) (string, bool,
 		}

 		c.sendMessagesReverse(chatID, messages.Messages)
+		return "", true, true
 	// get latest entries from history
 	case "history":
 		var limit int32 = 10
@ -1128,6 +1181,7 @@ func (c *Client) ProcessChatCommand(chatID int64, cmdline string) (string, bool,
 		}

 		c.sendMessagesReverse(chatID, messages)
+		return "", true, true
 	// chat members
 	case "members":
 		var query string
@ -1157,7 +1211,7 @@ func (c *Client) ProcessChatCommand(chatID int64, cmdline string) (string, bool,
 		return "", false, false
 	}

-	return "", true, true
+	return "Success", true, true
 }

 func (c *Client) cmdAdd(args []string) (string, bool) {
@ -1173,7 +1227,7 @@ func (c *Client) cmdAdd(args []string) (string, bool) {

 	c.subscribeToID(chat.Id, chat)

-	return "", true
+	return "Subscription sent", true
 }

 func (c *Client) cmdJoin(args []string) (string, bool) {
@ -1202,7 +1256,7 @@ func (c *Client) cmdJoin(args []string) (string, bool) {
 		}
 	}

-	return "", true
+	return "Joined", true
 }

 func (c *Client) cmdSupergroup(args []string, cmdline string) (string, bool) {
@ -1214,7 +1268,7 @@ func (c *Client) cmdSupergroup(args []string, cmdline string) (string, bool) {
 		return err.Error(), false
 	}

-	return "", true
+	return "Created", true
 }

 func (c *Client) cmdChannel(args []string, cmdline string) (string, bool) {
@ -1227,5 +1281,5 @@ func (c *Client) cmdChannel(args []string, cmdline string) (string, bool) {
 		return err.Error(), false
 	}

-	return "", true
+	return "Created", true
 }
--- a/telegram/connect.go
+++ b/telegram/connect.go
@ -129,6 +129,7 @@ func (c *Client) Connect(resource string) error {
 	tdlibClient, err := client.NewClient(c.authorizer, c.options...)
 	if err != nil {
 		c.locks.authorizationReady.Unlock()
+		c.wizardStageOrPrompt("cancel", "")
 		return errors.Wrap(err, "Couldn't initialize a Telegram client instance")
 	}

@ -137,6 +138,8 @@ func (c *Client) Connect(resource string) error {
 	// stage 3: if a client is succesfully created, AuthorizationStateReady is already reached
 	log.Warn("Authorization successful!")

+	c.wizardStageOrPrompt("success", "")
+
 	c.me, err = c.client.GetMe()
 	if err != nil {
 		log.Error("Could not retrieve me info")
@ -150,11 +153,13 @@ func (c *Client) Connect(resource string) error {
 	c.addResource(resource)

 	go func() {
-		_, err = c.client.GetChats(&client.GetChatsRequest{
+		chats, err := c.client.GetChats(&client.GetChatsRequest{
 			Limit: chatsLimit,
 		})
 		if err != nil {
 			log.Errorf("Could not retrieve chats: %v", err)
+		} else {
+			log.Infof("Obtained ≈%v chats for initialization", chats.TotalCount)
 		}

 		gateway.SubscribeToTransport(c.xmpp, c.jid)
@ -226,7 +231,7 @@ func (c *Client) Disconnect(resource string, quit bool) bool {
 	log.Warn("Disconnecting from Telegram network...")

 	// we're offline (unsubscribe if logout)
-	for _, id := range c.cache.ChatsKeys() {
+	for _, id := range c.cache.OwnChatsKeys() {
 		args := gateway.SimplePresence(id, "unavailable")
 		c.sendPresence(args...)
 	}
@ -255,6 +260,8 @@ func (c *Client) interactor() {
 		log.Infof("Telegram authorization state: %#v", stateType)
 		log.Debugf("%#v", state)

+		c.lastAuthorizationStateType = stateType
+
 		switch stateType {
 		// stage 0: set login
 		case client.TypeAuthorizationStateWaitPhoneNumber:
@ -262,12 +269,12 @@ func (c *Client) interactor() {
 			if c.Session.Login != "" {
 				c.authorizer.PhoneNumber <- c.Session.Login
 			} else {
-				gateway.SendServiceMessage(c.jid, "Please, enter your Telegram login via /login 12345", c.xmpp)
+				c.wizardStageOrPrompt("login", "Please, enter your Telegram login via /login 12345, or use the Login Wizard via Ad-Hoc commands")
 			}
 		// stage 1: wait for auth code
 		case client.TypeAuthorizationStateWaitCode:
 			log.Warn("Waiting for authorization code...")
-			gateway.SendServiceMessage(c.jid, "Please, enter authorization code via /code 12345", c.xmpp)
+			c.wizardStageOrPrompt("code", "Please, enter authorization code via /code 12345")
 		// stage 1b: wait for registration
 		case client.TypeAuthorizationStateWaitRegistration:
 			log.Warn("Waiting for full name...")
@ -275,7 +282,7 @@ func (c *Client) interactor() {
 		// stage 2: wait for 2fa
 		case client.TypeAuthorizationStateWaitPassword:
 			log.Warn("Waiting for 2FA password...")
-			gateway.SendServiceMessage(c.jid, "Please, enter 2FA passphrase via /password 12345", c.xmpp)
+			c.wizardStageOrPrompt("password", "Please, enter 2FA passphrase via /password 12345")
 		}
 		c.locks.authorizerReadLock.Unlock()
 	}
@ -294,6 +301,7 @@ func (c *Client) forceClose() {
 func (c *Client) close() {
 	c.locks.authorizerWriteLock.Lock()
 	if c.authorizer != nil && !c.authorizer.isClosed {
+		log.Debug("Closing authorizer")
 		c.authorizer.Close()
 	}
 	c.locks.authorizerWriteLock.Unlock()
@ -308,6 +316,7 @@ func (c *Client) close() {
 }

 func (c *Client) cancelAuth() {
+	c.StopLoginWizard()
 	c.close()
 	c.Session.Login = ""
 }
--- a/telegram/handlers.go
+++ b/telegram/handlers.go
@ -186,13 +186,13 @@ func (c *Client) updateHandler() {
 func (c *Client) updateUser(update *client.UpdateUser) {
 	c.cache.SetUser(update.User.Id, update.User)
 	show, status, presenceType := c.userStatusToText(update.User.Status, update.User.Id)
-	go c.ProcessStatusUpdate(update.User.Id, status, show, gateway.SPType(presenceType))
+	go c.ProcessStatusUpdate(update.User.Id, status, show, false, gateway.SPType(presenceType))
 }

 // user status changed
 func (c *Client) updateUserStatus(update *client.UpdateUserStatus) {
 	show, status, presenceType := c.userStatusToText(update.Status, update.UserId)
-	go c.ProcessStatusUpdate(update.UserId, status, show, gateway.SPImmed(false), gateway.SPType(presenceType))
+	go c.ProcessStatusUpdate(update.UserId, status, show, false, gateway.SPImmed(false), gateway.SPType(presenceType))
 }

 // new chat discovered
@ -206,14 +206,14 @@ func (c *Client) updateNewChat(update *client.UpdateNewChat) {
 			}
 		}

-		c.cache.SetChat(update.Chat.Id, update.Chat)
+		c.cache.SetChat(update.Chat.Id, update.Chat, true)

 		if update.Chat.Positions != nil && len(update.Chat.Positions) > 0 {
 			c.subscribeToID(update.Chat.Id, update.Chat)
 		}

 		if update.Chat.Id < 0 {
-			c.ProcessStatusUpdate(update.Chat.Id, update.Chat.Title, "chat")
+			c.ProcessStatusUpdate(update.Chat.Id, update.Chat.Title, "chat", true)
 		}
 	}()
 }
@ -245,12 +245,23 @@ func (c *Client) updateNewMessage(update *client.UpdateNewMessage) {
 		lock.Lock()
 		defer lock.Unlock()

-		c.updateLastMessageHash(update.Message.ChatId, update.Message.Id, update.Message.Content)
+		var forceCmd bool
+		if c.LastBotCmdString != "" && update.Message.IsOutgoing {
+			if update.Message.Content.MessageContentType() == client.TypeMessageText {
+				textMessage, _ := update.Message.Content.(*client.MessageText)
+
+				if textMessage.Text != nil && textMessage.Text.Text == c.LastBotCmdString {
+					forceCmd = true
+					c.LastBotCmdString = ""
+				}
+			}
+		}

 		// ignore self outgoing messages
 		if update.Message.IsOutgoing &&
 			update.Message.SendingState != nil &&
-			update.Message.SendingState.MessageSendingStateType() == client.TypeMessageSendingStatePending {
+			update.Message.SendingState.MessageSendingStateType() == client.TypeMessageSendingStatePending &&
+			!forceCmd {
 			return
 		}

@ -270,8 +281,6 @@ func (c *Client) updateMessageContent(update *client.UpdateMessageContent) {

 	markupFunction := c.getFormatter()

-	defer c.updateLastMessageHash(update.ChatId, update.MessageId, update.NewContent)
-
 	log.Debugf("newContent: %#v", update.NewContent)

 	lock := c.getChatMessageLock(update.ChatId)
@ -295,7 +304,7 @@ func (c *Client) updateMessageContent(update *client.UpdateMessageContent) {
 		return
 	}

-	if update.NewContent.MessageContentType() == client.TypeMessageText && c.hasLastMessageHashChanged(update.ChatId, update.MessageId, update.NewContent) {
+	if update.NewContent.MessageContentType() == client.TypeMessageText {
 		textContent := update.NewContent.(*client.MessageText)
 		log.Debugf("textContent: %#v", textContent.Text)

@ -303,6 +312,50 @@ func (c *Client) updateMessageContent(update *client.UpdateMessageContent) {
 		sId := strconv.FormatInt(update.MessageId, 10)
 		var isCarbon bool

+		go func() {
+			message, messageErr := c.client.GetMessage(&client.GetMessageRequest{
+				ChatId:    update.ChatId,
+				MessageId: update.MessageId,
+			})
+			if messageErr != nil {
+				// odnako za vremya puti
+				// sobaka mogla podrasti
+				c.MessageIdChangesLock.Lock()
+				idsMap, idsMapOk := c.MessageIdChanges[update.ChatId]
+				hadNoId := false
+				if idsMapOk {
+					newId, newIdOk := idsMap[update.MessageId]
+					if newIdOk {
+						if newId.Id == 0 {
+							hadNoId = true
+							c.MessageIdChangesLock.Unlock()
+							newId.Lock()
+						}
+						log.Infof("falling back to updated message id: %v/%v->%v", update.ChatId, update.MessageId, newId.Id)
+						message, messageErr = c.client.GetMessage(&client.GetMessageRequest{
+							ChatId:    update.ChatId,
+							MessageId: newId.Id,
+						})
+					}
+				}
+				if !hadNoId {
+					c.MessageIdChangesLock.Unlock()
+				}
+			}
+			var prefix string
+			if messageErr == nil {
+				if message.EditDate == 0 {
+					return
+				}
+				log.Debugf("editDate: %v", message.EditDate)
+
+				isCarbon = c.isCarbonsEnabled() && message.IsOutgoing
+				// reply correction support in clients is suboptimal yet, so cut them out for now
+				prefix, _ = c.messageToPrefix(message, "", "", true)
+			} else {
+				log.Errorf("No message %v/%v found, cannot reliably determine if it is a carbon and if it is edited: %v", update.ChatId, update.MessageId, messageErr.Error())
+			}
+
 			// use XEP-0308 edits only if the last message is edited for sure, fallback otherwise
 			if c.Session.NativeEdits {
 				lastXmppId, ok := c.getLastChatMessageId(update.ChatId)
@ -316,19 +369,6 @@ func (c *Client) updateMessageContent(update *client.UpdateMessageContent) {
 				}
 			}

-		message, messageErr := c.client.GetMessage(&client.GetMessageRequest{
-			ChatId:    update.ChatId,
-			MessageId: update.MessageId,
-		})
-		var prefix string
-		if messageErr == nil {
-			isCarbon = c.isCarbonsEnabled() && message.IsOutgoing
-			// reply correction support in clients is suboptimal yet, so cut them out for now
-			prefix, _ = c.messageToPrefix(message, "", "", true)
-		} else {
-			log.Errorf("No message %v/%v found, cannot reliably determine if it's a carbon", update.ChatId, update.MessageId)
-		}
-
 			var text strings.Builder

 			if replaceId == "" {
@ -354,17 +394,22 @@ func (c *Client) updateMessageContent(update *client.UpdateMessageContent) {
 			for _, jid := range jids {
 				gateway.SendMessage(jid, sChatId, text.String(), "e"+sId, c.xmpp, nil, replaceId, isCarbon, false)
 			}
+		}()
 	}
 }

 // message(s) deleted
 func (c *Client) updateDeleteMessages(update *client.UpdateDeleteMessages) {
 	if update.IsPermanent {
+		for _, deleteId := range update.MessageIds {
+			c.tryUnlockMessageId(update.ChatId, deleteId)
+		}
+
 		if c.Session.IsChatIgnored(update.ChatId) {
 			return
 		}
 		if c.Session.IgnoreGroupDeletions {
-			chatType, chatTypeErr := c.GetChatType(update.ChatId)
+			chatType, chatTypeErr := c.GetChatType(update.ChatId, false)
 			if chatTypeErr == nil && (chatType == ChatTypeBasicGroup || chatType == ChatTypeSupergroup) {
 				return
 			}
@ -398,7 +443,19 @@ func (c *Client) updateMessageSendSucceeded(update *client.UpdateMessageSendSucc
 		log.Errorf("failed to replace %v with %v: %v", update.OldMessageId, update.Message.Id, err.Error())
 	}

-	c.updateLastMessageHash(update.Message.ChatId, update.Message.Id, update.Message.Content)
+	c.MessageIdChangesLock.Lock()
+	idsMap, ok := c.MessageIdChanges[update.Message.ChatId]
+	if !ok {
+		idsMap = make(map[int64]*newId)
+		c.MessageIdChanges[update.Message.ChatId] = idsMap
+	}
+	id, ok := idsMap[update.OldMessageId]
+	if !ok {
+		id = newNewId()
+		idsMap[update.OldMessageId] = id
+	}
+	id.Id = update.Message.Id
+	c.MessageIdChangesLock.Unlock()

 	c.sendMarker(update.Message.ChatId, update.Message.Id, gateway.MarkerTypeReceived)

@ -409,6 +466,8 @@ func (c *Client) updateMessageSendSucceeded(update *client.UpdateMessageSendSucc
 	}
 }
 func (c *Client) updateMessageSendFailed(update *client.UpdateMessageSendFailed) {
+	c.tryUnlockMessageId(update.Message.ChatId, update.OldMessageId)
+
 	// clean uploaded files
 	file, _ := c.contentToFile(update.Message.Content)
 	if file != nil && file.Local != nil {
@ -421,9 +480,9 @@ func (c *Client) updateChatTitle(update *client.UpdateChatTitle) {
 	gateway.SetNickname(c.jid, strconv.FormatInt(update.ChatId, 10), update.Title, c.xmpp)

 	// set also the status (for group chats only)
-	chat, user, _ := c.GetContactByID(update.ChatId, nil)
+	chat, user, _ := c.GetContactByID(update.ChatId, nil, false)
 	if user == nil {
-		c.ProcessStatusUpdate(update.ChatId, update.Title, "chat", gateway.SPImmed(true))
+		c.ProcessStatusUpdate(update.ChatId, update.Title, "chat", false, gateway.SPImmed(true))
 	}

 	// update chat title in the cache
@ -435,3 +494,15 @@ func (c *Client) updateChatTitle(update *client.UpdateChatTitle) {
 func (c *Client) updateChatReadOutbox(update *client.UpdateChatReadOutbox) {
 	c.sendMarker(update.ChatId, update.LastReadOutboxMessageId, gateway.MarkerTypeDisplayed)
 }
+
+func (c *Client) tryUnlockMessageId(chatId, messageId int64) {
+	c.MessageIdChangesLock.Lock()
+	idsMap, ok := c.MessageIdChanges[chatId]
+	if ok {
+		id, ok := idsMap[messageId]
+		if ok {
+			id.Unlock()
+		}
+	}
+	c.MessageIdChangesLock.Unlock()
+}
--- a/telegram/loginwizard.go
+++ b/telegram/loginwizard.go
@ -0,0 +1,82 @@
+package telegram
+
+import (
+	"dev.narayana.im/narayana/telegabber/xmpp/gateway"
+
+	log "github.com/sirupsen/logrus"
+	"github.com/zelenin/go-tdlib/client"
+)
+
+// StartLoginWizard initiates a loginWizard object
+func (c *Client) StartLoginWizard(inCommand bool) {
+	if c.loginWizard == nil {
+		c.loginWizard = &loginWizardMetadata{
+			nextStage:   make(chan string, 1),
+			commandSent: inCommand,
+		}
+	} else {
+		c.loginWizard.commandSent = inCommand
+	}
+}
+
+// StopLoginWizard safely destroys the loginWizard object
+func (c *Client) StopLoginWizard() {
+	c.locks.loginWizardReadLock.Lock()
+	c.locks.loginWizardWriteLock.Lock()
+	if c.loginWizard != nil {
+		close(c.loginWizard.nextStage)
+		c.loginWizard = nil
+	}
+	c.locks.loginWizardReadLock.Unlock()
+	c.locks.loginWizardWriteLock.Unlock()
+}
+
+// GetLoginWizardNextStage waits for the next stage from the channel
+func (c *Client) GetLoginWizardNextStage() string {
+	c.locks.loginWizardReadLock.Lock()
+	defer c.locks.loginWizardReadLock.Unlock()
+
+	if c.loginWizard != nil {
+		if c.loginWizard.commandSent {
+			log.Debugf("waiting for nextStage...")
+			nextStage := <-c.loginWizard.nextStage
+			c.loginWizard.commandSent = false
+			c.loginWizard.chanBusy = false
+			log.Debugf("yielded stage %v", nextStage)
+			return nextStage
+		} else {
+			if c.lastAuthorizationStateType == client.TypeAuthorizationStateWaitPhoneNumber ||
+				c.lastAuthorizationStateType == client.TypeAuthorizationStateClosing ||
+				c.Session.Login == "" {
+				return "login"
+			}
+			switch c.lastAuthorizationStateType {
+			case client.TypeAuthorizationStateWaitCode:
+				return "code"
+			case client.TypeAuthorizationStateWaitPassword:
+				return "password"
+			}
+		}
+	}
+
+	return ""
+}
+
+func (c *Client) wizardStageOrPrompt(stage, message string) {
+	c.locks.loginWizardWriteLock.Lock()
+	if c.loginWizard == nil {
+		c.locks.loginWizardWriteLock.Unlock()
+		if message != "" {
+			gateway.SendServiceMessage(c.jid, message, c.xmpp)
+		}
+	} else {
+		if !c.loginWizard.chanBusy {
+			log.Debugf("writing wizard stage %v", stage)
+			c.loginWizard.nextStage <- stage
+		} else {
+			log.Warn("Skipping stage %v, wizard cannot keep up", stage)
+		}
+		c.loginWizard.chanBusy = true
+		c.locks.loginWizardWriteLock.Unlock()
+	}
+}
--- a/telegram/utils.go
+++ b/telegram/utils.go
@ -4,10 +4,8 @@ import (
 	"bytes"
 	"crypto/sha1"
 	"encoding/base64"
-	"encoding/binary"
 	"fmt"
 	"github.com/pkg/errors"
-	"hash/maphash"
 	"io"
 	"io/ioutil"
 	"net/http"
@ -47,6 +45,16 @@ type messageStub struct {
 	Text      string
 }

+type BotCommand struct {
+	Command     string
+	Description string
+}
+
+type BotLink struct {
+	Description string
+	Link        string
+}
+
 const (
 	typeFileDataSha1 byte = iota
 	typeFileDataBase64
@ -83,8 +91,10 @@ const (
 	MembersListBannedAndAdministrators
 )

+const AVATAR_SIZE_LIMIT int64 = 128 * 1024
+
 // GetContactByUsername resolves username to user id retrieves user and chat information
-func (c *Client) GetContactByUsername(username string) (*client.Chat, *client.User, error) {
+func (c *Client) GetContactByUsername(username string, own bool) (*client.Chat, *client.User, error) {
 	if !c.Online() {
 		return nil, nil, errOffline
 	}
@ -109,11 +119,11 @@ func (c *Client) GetContactByUsername(username string) (*client.Chat, *client.Us
 		}
 	}

-	return c.GetContactByID(userID, chat)
+	return c.GetContactByID(userID, chat, own)
 }

 // GetContactByID gets user and chat information from cache (or tries to retrieve it, if missing)
-func (c *Client) GetContactByID(id int64, chat *client.Chat) (*client.Chat, *client.User, error) {
+func (c *Client) GetContactByID(id int64, chat *client.Chat, own bool) (*client.Chat, *client.User, error) {
 	if !c.Online() || id == 0 {
 		return nil, nil, errOffline
 	}
@ -148,9 +158,9 @@ func (c *Client) GetContactByID(id int64, chat *client.Chat) (*client.Chat, *cli
 				return nil, nil, err
 			}

-			c.cache.SetChat(id, cacheChat)
+			c.cache.SetChat(id, cacheChat, own)
 		} else {
-			c.cache.SetChat(id, chat)
+			c.cache.SetChat(id, chat, own)
 		}
 	}
 	if chat == nil {
@ -161,7 +171,7 @@ func (c *Client) GetContactByID(id int64, chat *client.Chat) (*client.Chat, *cli
 }

 // GetChatType obtains chat type from its information
-func (c *Client) GetChatType(id int64) (ChatType, error) {
+func (c *Client) GetChatType(id int64, own bool) (ChatType, error) {
 	if !c.Online() || id == 0 {
 		return ChatTypeUnknown, errOffline
 	}
@ -177,7 +187,7 @@ func (c *Client) GetChatType(id int64) (ChatType, error) {
 			return ChatTypeUnknown, err
 		}

-		c.cache.SetChat(id, chat)
+		c.cache.SetChat(id, chat, own)
 	}

 	chatType := chat.Type.ChatTypeType()
@ -199,8 +209,8 @@ func (c *Client) GetChatType(id int64) (ChatType, error) {
 }

 // IsPM checks if a chat is PM
-func (c *Client) IsPM(id int64) (bool, error) {
-	typ, err := c.GetChatType(id)
+func (c *Client) IsPM(id int64, own bool) (bool, error) {
+	typ, err := c.GetChatType(id, own)
 	if err != nil {
 		return false, err
 	}
@ -211,6 +221,40 @@ func (c *Client) IsPM(id int64) (bool, error) {
 	return false, nil
 }

+// IsBot checks if a chat is a bot
+func (c *Client) IsBot(id int64, own bool) (bool, error) {
+	_, user, err := c.GetContactByID(id, nil, own)
+	if err != nil {
+		return false, err
+	}
+	if user == nil || user.Type == nil {
+		return false, nil
+	}
+
+	return user.Type.UserTypeType() == client.TypeUserTypeBot, nil
+}
+
+// GetBotMenu retrieves the bot's attachment menu
+func (c *Client) GetBotMenu(id int64) (*BotLink, []*BotCommand, error) {
+	fullInfo, err := c.client.GetUserFullInfo(&client.GetUserFullInfoRequest{
+		UserId: id,
+	})
+	if err == nil && fullInfo.BotInfo != nil {
+		if fullInfo.BotInfo.MenuButton != nil {
+			menuButton := fullInfo.BotInfo.MenuButton
+			return &BotLink{menuButton.Text, menuButton.Url}, nil, nil
+		} else {
+			var commands []*BotCommand
+			for _, command := range fullInfo.BotInfo.Commands {
+				commands = append(commands, &BotCommand{command.Command, command.Description})
+			}
+			return nil, commands, nil
+		}
+	}
+
+	return nil, nil, err
+}
+
 func (c *Client) userStatusToText(status client.UserStatus, chatID int64) (string, string, string) {
 	var show, textStatus, presenceType string

@ -273,6 +317,12 @@ func (c *Client) getFileData(tgFile *client.File, typ byte) string {
 		priority = 32
 	}

+	// avoid not-well-formed stanza errors
+	if typ == typeFileDataBase64 && c.GetPhotoSize(tgFile) > AVATAR_SIZE_LIMIT {
+		log.Warnf("Photo %v skipped as it's too huge", tgFile.Id)
+		return ""
+	}
+
 	file, path, err := c.ForceOpenFile(tgFile, priority)
 	if err == nil {
 		defer file.Close()
@ -315,16 +365,16 @@ func (c *Client) SetEmptyAvatarHash(chatId int64) {
 	c.AvatarHashesLock.Unlock()
 }

-// GetPhotoSha1AndSize obtains data for PEP
-func (c *Client) GetPhotoSha1AndSize(photo *client.File, chatId int64) (string, int64) {
-	sha1 := c.GetPhotoSha1(photo, chatId)
-
+// GetPhotoSize return at least a rough size
+func (c *Client) GetPhotoSize(photo *client.File) int64 {
+	if photo == nil {
+		return 0
+	}
 	size := photo.Size
 	if size == 0 {
 		size = photo.ExpectedSize
 	}
-
-	return sha1, size
+	return size
 }

 // GetPhotoSha1 computes the photo hash
@ -345,7 +395,7 @@ func (c *Client) GetPhotoBase64(photo *client.File) string {
 }

 // ProcessStatusUpdate sets contact status
-func (c *Client) ProcessStatusUpdate(chatID int64, status string, show string, oldArgs ...args.V) error {
+func (c *Client) ProcessStatusUpdate(chatID int64, status string, show string, own bool, oldArgs ...args.V) error {
 	if !c.Online() {
 		return nil
 	}
@ -354,7 +404,7 @@ func (c *Client) ProcessStatusUpdate(chatID int64, status string, show string, o
 		"chat_id": chatID,
 	}).Info("Status update for")

-	chat, user, err := c.GetContactByID(chatID, nil)
+	chat, user, err := c.GetContactByID(chatID, nil, own)
 	if err != nil {
 		return err
 	}
@ -420,7 +470,7 @@ func (c *Client) FormatContact(chatID int64) string {
 		return ""
 	}

-	chat, user, err := c.GetContactByID(chatID, nil)
+	chat, user, err := c.GetContactByID(chatID, nil, false)
 	if err != nil {
 		return "unknown contact: " + err.Error()
 	}
@ -1041,7 +1091,7 @@ func (c *Client) isCarbonsEnabled() bool {
 }

 func (c *Client) messageToPrefix(message *client.Message, previewString string, fileString string, suppressReply bool) (string, *gateway.Reply) {
-	isPM, err := c.IsPM(message.ChatId)
+	isPM, err := c.IsPM(message.ChatId, true)
 	if err != nil {
 		log.Errorf("Could not determine if chat is PM: %v", err)
 	}
@ -1066,7 +1116,8 @@ func (c *Client) messageToPrefix(message *client.Message, previewString string,
 			}
 		}
 	}
-	if !isPM || !c.Session.HideIds {
+	// with hideids options enabled, hide the id for everything but non-carbons in group chats
+	if (!isPM && !(c.isCarbonsEnabled() && message.IsOutgoing)) || !c.Session.HideIds {
 		prefix = append(prefix, directionChar+strconv.FormatInt(message.Id, 10))
 	}
 	// show sender in group chats
@ -1164,14 +1215,15 @@ func (c *Client) ProcessIncomingMessage(chatId int64, message *client.Message) {
 			ChatId: chatId,
 		})
 		if err == nil {
-			c.cache.SetChat(chatId, chat)
-			go c.ProcessStatusUpdate(chatId, "", "", gateway.SPImmed(true))
+			c.cache.SetChat(chatId, chat, true)
+			go c.ProcessStatusUpdate(chatId, "", "", true, gateway.SPImmed(true))
 			text = "<Chat photo has changed>"

 			if chat.Photo == nil {
 				c.SetEmptyAvatarHash(chatId)
 			} else {
-				sha1, size := c.GetPhotoSha1AndSize(chat.Photo.Small, chatId)
+				sha1 := c.GetPhotoSha1(chat.Photo.Small, chatId)
+				size := c.GetPhotoSize(chat.Photo.Small)

 				for resource := range c.resourcesRange() {
 					features, ok := c.XmppClientFeatures[resource]
@ -1206,10 +1258,8 @@ func (c *Client) ProcessIncomingMessage(chatId int64, message *client.Message) {
 			var ignorePrefix bool
 			if oobSwap {
 				if text == "" || message.Content.MessageContentType() == client.TypeMessageSticker {
-					isPM, err := c.IsPM(chatId)
-					if err == nil {
-						ignorePrefix = isPM && c.isCarbonsEnabled()
-					}
+					chatType, err := c.GetChatType(chatId, true)
+					ignorePrefix = err == nil && (chatType != ChatTypeBasicGroup && chatType != ChatTypeSupergroup) && c.isCarbonsEnabled()
 				}
 			}

@ -1223,7 +1273,11 @@ func (c *Client) ProcessIncomingMessage(chatId int64, message *client.Message) {

 				if text != "" {
 					if prefix != "" {
-						newText.WriteString(c.getPrefixSeparator(chatId))
+						separator := c.getPrefixSeparator(chatId)
+						newText.WriteString(separator)
+						if reply != nil {
+							reply.End += uint64(len(separator))
+						}
 					}
 					newText.WriteString(text)
 				}
@ -1275,13 +1329,13 @@ func (c *Client) PrepareOutgoingMessageContent(text string) client.InputMessageC
 }

 // ProcessOutgoingMessage executes commands or sends messages to mapped chats, returns message id
-func (c *Client) ProcessOutgoingMessage(chatID int64, text string, returnJid string, replyId int64, replaceId int64) int64 {
+func (c *Client) ProcessOutgoingMessage(chatID int64, text string, returnJid string, replyId int64, replaceId int64, raw bool) int64 {
 	if !c.Online() {
 		// we're offline
 		return 0
 	}

-	if replaceId == 0 && (strings.HasPrefix(text, "/") || strings.HasPrefix(text, "!")) {
+	if replaceId == 0 && !raw && (strings.HasPrefix(text, "/") || strings.HasPrefix(text, "!")) {
 		// try to execute commands
 		response, isCommand, _ := c.ProcessChatCommand(chatID, text)
 		if response != "" {
@ -1406,9 +1460,9 @@ func (c *Client) prepareOutgoingMessageContent(text string, file *client.InputFi
 	return content
 }

-// ChatsKeys proxies the following function from unexported cache
-func (c *Client) ChatsKeys() []int64 {
-	return c.cache.ChatsKeys()
+// OwnChatsKeys proxies the following function from unexported cache
+func (c *Client) OwnChatsKeys() []int64 {
+	return c.cache.OwnChatsKeys()
 }

 // StatusesRange proxies the following function from unexported cache
@ -1465,8 +1519,8 @@ func (c *Client) roster(resource string) {

 	log.Warnf("Sending roster for %v", resource)

-	for _, chat := range c.cache.ChatsKeys() {
-		c.ProcessStatusUpdate(chat, "", "")
+	for _, chat := range c.cache.OwnChatsKeys() {
+		c.ProcessStatusUpdate(chat, "", "", true)
 	}

 	c.sendPresence(gateway.SPStatus("Logged in as: " + c.Session.Login))
@ -1580,7 +1634,7 @@ func (c *Client) subscribeToID(id int64, chat *client.Chat) {
 	args := gateway.SimplePresence(id, "subscribe")

 	if chat == nil {
-		chat, _, _ = c.GetContactByID(id, nil)
+		chat, _, _ = c.GetContactByID(id, nil, true)
 	}
 	if chat != nil {
 		args = append(args, gateway.SPNickname(chat.Title))
@ -1610,7 +1664,7 @@ func (c *Client) prepareDiskSpace(size uint64) {

 func (c *Client) GetVcardInfo(toID int64) (VCardInfo, error) {
 	var info VCardInfo
-	chat, user, err := c.GetContactByID(toID, nil)
+	chat, user, err := c.GetContactByID(toID, nil, false)
 	if err != nil {
 		return info, err
 	}
@ -1637,7 +1691,7 @@ func (c *Client) GetVcardInfo(toID int64) (VCardInfo, error) {
 }

 func (c *Client) UpdateChatNicknames() {
-	for _, id := range c.cache.ChatsKeys() {
+	for _, id := range c.cache.OwnChatsKeys() {
 		chat, ok := c.cache.GetChat(id)
 		if ok {
 			newArgs := []args.V{
@ -1715,61 +1769,6 @@ func (c *Client) getCarbonFullJids(isOutgoing bool, ignoredResource string) []st
 	return jids
 }

-func (c *Client) calculateMessageHash(messageId int64, content client.MessageContent) uint64 {
-	var h maphash.Hash
-	h.SetSeed(c.msgHashSeed)
-
-	buf8 := make([]byte, 8)
-	binary.BigEndian.PutUint64(buf8, uint64(messageId))
-	h.Write(buf8)
-
-	if content != nil && content.MessageContentType() == client.TypeMessageText {
-		textContent, ok := content.(*client.MessageText)
-		if !ok {
-			uhOh()
-		}
-
-		if textContent.Text != nil {
-			h.WriteString(textContent.Text.Text)
-			for _, entity := range textContent.Text.Entities {
-				buf4 := make([]byte, 4)
-				binary.BigEndian.PutUint32(buf4, uint32(entity.Offset))
-				h.Write(buf4)
-				binary.BigEndian.PutUint32(buf4, uint32(entity.Length))
-				h.Write(buf4)
-				h.WriteString(entity.Type.TextEntityTypeType())
-			}
-		}
-	}
-
-	return h.Sum64()
-}
-
-func (c *Client) updateLastMessageHash(chatId, messageId int64, content client.MessageContent) {
-	c.locks.lastMsgHashesLock.Lock()
-	defer c.locks.lastMsgHashesLock.Unlock()
-
-	c.lastMsgHashes[chatId] = c.calculateMessageHash(messageId, content)
-}
-
-func (c *Client) hasLastMessageHashChanged(chatId, messageId int64, content client.MessageContent) bool {
-	c.locks.lastMsgHashesLock.Lock()
-	defer c.locks.lastMsgHashesLock.Unlock()
-
-	oldHash, ok := c.lastMsgHashes[chatId]
-	newHash := c.calculateMessageHash(messageId, content)
-
-	if !ok {
-		log.Warnf("Last message hash for chat %v does not exist", chatId)
-	}
-	log.WithFields(log.Fields{
-		"old hash": oldHash,
-		"new hash": newHash,
-	}).Info("Message hashes")
-
-	return !ok || oldHash != newHash
-}
-
 func (c *Client) UpdateLastChatMessageId(chatId int64, messageId string) {
 	c.locks.lastMsgIdsLock.Lock()
 	defer c.locks.lastMsgIdsLock.Unlock()
@ -1797,6 +1796,13 @@ func (c *Client) usernamesToString(usernames []string) string {
 	return strings.Join(atUsernames, ", ")
 }

+func (c *Client) GetTZD() string {
+	if c.Session.Timezone == "" {
+		return "Z"
+	}
+	return c.Session.Timezone
+}
+
 // GetChatMembers retrieves a list of chat members. "Limited" mode works only if there are no more than 20 members at all
 func (c *Client) GetChatMembers(chatID int64, limited bool, query string, membersList MembersList) ([]*client.ChatMember, error) {
 	var filters []client.ChatMembersFilter
@ -1815,7 +1821,7 @@ func (c *Client) GetChatMembers(chatID int64, limited bool, query string, member
 	if limited {
 		limit = 20

-		chat, _, err := c.GetContactByID(chatID, nil)
+		chat, _, err := c.GetContactByID(chatID, nil, true)
 		if err != nil {
 			return nil, err
 		} else if chat == nil {
--- a/xmpp/component.go
+++ b/xmpp/component.go
@ -39,10 +39,11 @@ var sizeRegex = regexp.MustCompile("\\A([0-9]+) ?([KMGTPE]?B?)\\z")

 // NewComponent starts a new component and wraps it in
 // a stream manager that you should start yourself
-func NewComponent(conf config.XMPPConfig, tc config.TelegramConfig, idsPath string) (*xmpp.StreamManager, *xmpp.Component, error) {
+func NewComponent(conf config.XMPPConfig, tc config.TelegramConfig, idsPath string, version string) (*xmpp.StreamManager, *xmpp.Component, error) {
 	var err error

 	gateway.Jid, err = stanza.NewJid(conf.Jid)
+	gateway.Version = version
 	if err != nil {
 		return nil, nil, err
 	}
@ -141,11 +142,24 @@ func heartbeat(component *xmpp.Component) {
 						chatID,
 						session.LastSeenStatus(delayedStatus.TimestampOnline),
 						"away",
+						true,
 					)
 					delete(session.DelayedStatuses, chatID)
 				}
 			}
 			session.DelayedStatusesLock.Unlock()
+
+			// shrink message id maps
+			session.MessageIdChangesLock.Lock()
+			for _, idsMap := range session.MessageIdChanges {
+				for oldMessageId, newId := range idsMap {
+					if newId.Ts < now - 60 {
+						newId.Unlock()
+						delete(idsMap, oldMessageId)
+					}
+				}
+			}
+			session.MessageIdChangesLock.Unlock()
 		}
 		sessionLock.Unlock()

--- a/xmpp/extensions/extensions.go
+++ b/xmpp/extensions/extensions.go
@ -213,6 +213,20 @@ type QueryRegisterRemove struct {
 	XMLName xml.Name `xml:"remove"`
 }

+// EntityTime is from XEP-0202
+type EntityTime struct {
+	XMLName   xml.Name          `xml:"urn:xmpp:time time"`
+	Tzo       string            `xml:"tzo"`
+	Utc       string            `xml:"utc"`
+	ResultSet *stanza.ResultSet `xml:"set,omitempty"`
+}
+
+// AttachTo is from XEP-0367
+type AttachTo struct {
+	XMLName xml.Name `xml:"urn:xmpp:message-attaching:1 attach-to"`
+	Id      string   `xml:"id,attr"`
+}
+
 // Namespace is a namespace!
 func (c PresenceNickExtension) Namespace() string {
 	return c.XMLName.Space
@ -278,11 +292,26 @@ func (c QueryRegister) GetSet() *stanza.ResultSet {
 	return c.ResultSet
 }

+// Namespace is a namespace!
+func (c EntityTime) Namespace() string {
+	return c.XMLName.Space
+}
+
+// GetSet getsets!
+func (c EntityTime) GetSet() *stanza.ResultSet {
+	return c.ResultSet
+}
+
 // Name is a packet name
 func (ClientMessage) Name() string {
 	return "message"
 }

+// Namespace is a namespace!
+func (c AttachTo) Namespace() string {
+	return c.XMLName.Space
+}
+
 // NewReplyFallback initializes a fallback range
 func NewReplyFallback(start uint64, end uint64) Fallback {
 	return Fallback{
@ -362,4 +391,16 @@ func init() {
 		"jabber:iq:register",
 		"query",
 	}, QueryRegister{})
+
+	// entity time
+	stanza.TypeRegistry.MapExtension(stanza.PKTIQ, xml.Name{
+		"urn:xmpp:time",
+		"time",
+	}, EntityTime{})
+
+	// attach-to
+	stanza.TypeRegistry.MapExtension(stanza.PKTMessage, xml.Name{
+		"urn:xmpp:message-attaching:1",
+		"attach-to",
+	}, AttachTo{})
 }
--- a/xmpp/gateway/gateway.go
+++ b/xmpp/gateway/gateway.go
@ -50,6 +50,9 @@ var QueueLock = sync.Mutex{}
 // Jid stores the component's JID object
 var Jid *stanza.Jid

+// Version stores this software's version
+var Version string
+
 // IdsDB provides a disk-backed bidirectional dictionary of Telegram and XMPP ids
 var IdsDB badger.IdsDB

--- a/xmpp/handlers.go
+++ b/xmpp/handlers.go
@ -7,6 +7,8 @@ import (
 	"sort"
 	"strconv"
 	"strings"
+	"sync"
+	"time"

 	"dev.narayana.im/narayana/telegabber/persistence"
 	"dev.narayana.im/narayana/telegabber/telegram"
@ -25,6 +27,10 @@ const (
 	TypeVCard4
 )

+// kludge for client resuming after the transport restart (by full jids)
+var probeFired = make(map[string]bool)
+var probeFiredLock = sync.Mutex{}
+
 func logPacketType(p stanza.Packet) {
 	log.Warnf("Ignoring packet: %T\n", p)
 }
@ -70,6 +76,16 @@ func HandleIq(s xmpp.Sender, p stanza.Packet) {
 			go handleGetQueryRegister(s, iq)
 			return
 		}
+		_, ok = iq.Payload.(*stanza.Version)
+		if ok {
+			go handleGetVersion(s, iq)
+			return
+		}
+		_, ok = iq.Payload.(*extensions.EntityTime)
+		if ok {
+			go handleGetEntityTime(s, iq)
+			return
+		}
 	} else if iq.Type == stanza.IQTypeSet {
 		query, ok := iq.Payload.(*extensions.QueryRegister)
 		if ok {
@ -133,12 +149,15 @@ func HandleMessage(s xmpp.Sender, p stanza.Packet) {
 			var reply extensions.Reply
 			var fallback extensions.Fallback
 			var replace extensions.Replace
+			var attachTo extensions.AttachTo
 			msg.Get(&reply)
 			msg.Get(&fallback)
 			msg.Get(&replace)
+			msg.Get(&attachTo)
 			log.Debugf("reply: %#v", reply)
 			log.Debugf("fallback: %#v", fallback)
 			log.Debugf("replace: %#v", replace)
+			log.Debugf("attachTo: %#v", attachTo)

 			var replyId int64
 			var err error
@ -204,7 +223,7 @@ func HandleMessage(s xmpp.Sender, p stanza.Packet) {

 			session.SendMessageLock.Lock()
 			defer session.SendMessageLock.Unlock()
-			tgMessageId := session.ProcessOutgoingMessage(toID, text, msg.From, replyId, replaceId)
+			tgMessageId := session.ProcessOutgoingMessage(toID, text, msg.From, replyId, replaceId, false)
 			if tgMessageId != 0 {
 				if replaceId != 0 {
 					// not needed (is it persistent among clients though?)
@ -214,12 +233,16 @@ func HandleMessage(s xmpp.Sender, p stanza.Packet) {
 					} */
 					session.AddToEditOutbox(replace.Id, resource)
 				} else {
-					err = gateway.IdsDB.Set(session.Session.Login, bare, toID, tgMessageId, msg.Id)
+					messageId := msg.Id
+					if attachTo.Id != "" {
+						messageId = attachTo.Id
+					}
+					err = gateway.IdsDB.Set(session.Session.Login, bare, toID, tgMessageId, messageId)
 					if err == nil {
 						// session.AddToOutbox(msg.Id, resource)
-						session.UpdateLastChatMessageId(toID, msg.Id)
+						session.UpdateLastChatMessageId(toID, messageId)
 					} else {
-						log.Errorf("Failed to save ids %v/%v %v", toID, tgMessageId, msg.Id)
+						log.Errorf("Failed to save ids %v/%v %v", toID, tgMessageId, messageId)
 					}
 				}
 			} else {
@ -358,7 +381,7 @@ func handleSubscription(s xmpp.Sender, p stanza.Presence) {
 	if !ok {
 		return
 	}
-	go session.ProcessStatusUpdate(toID, "", "", gateway.SPImmed(false))
+	go session.ProcessStatusUpdate(toID, "", "", true, gateway.SPImmed(false))
 }

 func handlePresence(s xmpp.Sender, p stanza.Presence) {
@ -410,6 +433,13 @@ func handlePresence(s xmpp.Sender, p stanza.Presence) {
 			if err != nil {
 				log.Error(errors.Wrap(err, "TDlib connection failure"))
 			} else {
+				var probeFiredForFrom bool
+				probeFiredLock.Lock()
+				_, probeFiredForFrom = probeFired[p.From]
+				probeFired[p.From] = true
+				probeFiredLock.Unlock()
+
+				if p.Type != "probe" || !probeFiredForFrom {
 					for status := range session.StatusesRange() {
 						show, description, typ := status.Destruct()
 						newArgs := []args.V{
@ -422,12 +452,14 @@ func handlePresence(s xmpp.Sender, p stanza.Presence) {
 							status.ID,
 							description,
 							show,
+							true,
 							newArgs...,
 						)
 					}
 					probeClientFeatures(p.From, component)
 					session.UpdateChatNicknames()
 				}
+			}
 		}()
 	}
 }
@ -535,7 +567,7 @@ func handleGetAvatarDataIq(s xmpp.Sender, iq *stanza.IQ, pubsub *stanza.PubSubGe
 	if !ok {
 		log.Info("Could not find avatar in cache, fetching immediately")

-		chat, _, err := session.GetContactByID(chatId, nil)
+		chat, _, err := session.GetContactByID(chatId, nil, true)
 		if err != nil || chat == nil || chat.Photo == nil {
 			return
 		}
@ -596,7 +628,7 @@ func getTelegramChatType(from string, to string) (telegram.ChatType, error) {
 		if ok {
 			session, ok := sessions[bare]
 			if ok {
-				return session.GetChatType(toId)
+				return session.GetChatType(toId, true)
 			}
 		}
 	}
@ -629,6 +661,8 @@ func handleGetDiscoInfo(s xmpp.Sender, iq *stanza.IQ, di *stanza.DiscoInfo) {
 			disco.AddFeatures("jabber:iq:register")
 		}
 		disco.AddFeatures(gateway.NSCommand)
+		disco.AddFeatures("jabber:iq:version")
+		disco.AddFeatures("urn:xmpp:time")
 	} else {
 		chatType, chatTypeErr := getTelegramChatType(iq.From, iq.To)

@ -679,25 +713,48 @@ func handleGetDiscoItems(s xmpp.Sender, iq *stanza.IQ, di *stanza.DiscoItems) {

 	log.Debugf("discoItems: %#v", di)

-	_, ok := toToID(iq.To)
+	toID, toOk := toToID(iq.To)
 	if di.Node == gateway.NSCommand {
 		answer.Payload = di

 		chatType, chatTypeErr := getTelegramChatType(iq.From, iq.To)

 		var cmdType telegram.CommandType
-		if ok {
+		if toOk {
 			cmdType = telegram.CommandTypeChat
 		} else {
 			cmdType = telegram.CommandTypeTransport
 		}

+		var isOnline bool
+		bare, _, ok := gateway.SplitJID(iq.From)
+		if ok {
+			session, ok := sessions[bare]
+			if ok {
+				isOnline = session.Online()
+
+				if toOk {
+					isBot, err := session.IsBot(toID, true)
+					if err == nil && isBot {
+						di.AddItem(iq.To, "botmenu", "Bot Menu")
+					}
+				}
+			}
+		}
+
+		if !(toOk || isOnline) {
+			di.AddItem(iq.To, "loginwizard", "Login Wizard")
+		}
+
 		commands := telegram.GetCommands(cmdType)
-		for _, name := range telegram.SortedCommandKeys(commands) {
+		for _, name := range telegram.SortedCommandKeys(commands, telegram.OnlineFilterAny) {
 			command := commands[name]
 			if chatTypeErr == nil && !telegram.IsCommandForChatType(command, chatType) {
 				continue
 			}
+			if !isOnline && command.LoginOnly {
+				continue
+			}
 			di.AddItem(iq.To, name, telegram.CommandToHelpString(name, command))
 		}
 	} else {
@ -764,6 +821,77 @@ func handleGetQueryRegister(s xmpp.Sender, iq *stanza.IQ) {
 	}
 }

+func handleGetVersion(s xmpp.Sender, iq *stanza.IQ) {
+	component, ok := s.(*xmpp.Component)
+	if !ok {
+		log.Error("Not a component")
+		return
+	}
+
+	answer, err := stanza.NewIQ(stanza.Attrs{
+		Type: stanza.IQTypeResult,
+		From: iq.To,
+		To:   iq.From,
+		Id:   iq.Id,
+		Lang: "en",
+	})
+	if err != nil {
+		log.Errorf("Failed to create answer IQ: %v", err)
+		return
+	}
+
+	answer.Version().SetInfo(gateway.Jid.Resource, gateway.Version, "")
+
+	log.Debugf("%#v", answer.Payload)
+
+	_ = gateway.ResumableSend(component, answer)
+}
+
+func handleGetEntityTime(s xmpp.Sender, iq *stanza.IQ) {
+	component, ok := s.(*xmpp.Component)
+	if !ok {
+		log.Error("Not a component")
+		return
+	}
+
+	// separate declaration is crucial for passing as pointer to defer
+	var answer *stanza.IQ
+	var err error
+	answer, err = stanza.NewIQ(stanza.Attrs{
+		Type: stanza.IQTypeResult,
+		From: iq.To,
+		To:   iq.From,
+		Id:   iq.Id,
+		Lang: "en",
+	})
+	if err != nil {
+		log.Errorf("Failed to create answer IQ: %v", err)
+		return
+	}
+
+	defer gateway.ResumableSend(component, answer)
+
+	fromJid, err := stanza.NewJid(iq.From)
+	if err != nil {
+		log.Error("Invalid from JID!")
+		return
+	}
+
+	session, ok := sessions[fromJid.Bare()]
+	if !ok {
+		log.Error("IQ from stranger")
+		return
+	}
+
+	entityTime := extensions.EntityTime{
+		Tzo: session.GetTZD(),
+		Utc: time.Now().UTC().Format(time.RFC3339),
+	}
+	answer.Payload = &entityTime
+
+	log.Debugf("%#v", entityTime)
+}
+
 func handleSetQueryRegister(s xmpp.Sender, iq *stanza.IQ, query *extensions.QueryRegister) {
 	component, ok := s.(*xmpp.Component)
 	if !ok {
@ -851,7 +979,13 @@ func handleSetQueryCommand(s xmpp.Sender, iq *stanza.IQ, command *stanza.Command
 		return
 	}

-	defer gateway.ResumableSend(component, answer)
+	cancelSend := false
+
+	defer func() {
+		if !cancelSend {
+			gateway.ResumableSend(component, answer)
+		}
+	}()

 	log.Debugf("command: %#v", command)

@ -877,6 +1011,107 @@ func handleSetQueryCommand(s xmpp.Sender, iq *stanza.IQ, command *stanza.Command
 		cmdType = telegram.CommandTypeTransport
 	}
 	if form != nil {
+		if command.Node == "config" {
+			session, ok := sessions[bare]
+			if ok {
+				var infoStrings []string
+				var warnString, errString string
+				for _, field := range form.Fields {
+					if len(field.ValuesList) > 0 {
+						fieldValue := field.ValuesList[0]
+
+						if gateway.MessageOutgoingPermissionVersion == 0 && field.Var == "carbons" && fieldValue == "true" {
+							warnString = "The server did not allow to enable carbons"
+							continue
+						}
+
+						// 10. In accordance with Section 3.2.2.1 of XML Schema Part 2: Datatypes, the allowable
+						// lexical representations for the xs:boolean datatype are the strings "0" and "false"
+						// for the concept 'false' and the strings "1" and "true" for the concept 'true';
+						// implementations MUST support both styles of lexical representation.
+						if persistence.PropertyType(field.Var) == persistence.PropertyTypeBool {
+							if fieldValue == "0" {
+								fieldValue = "false"
+							}
+							if fieldValue == "1" {
+								fieldValue = "true"
+							}
+						}
+
+						oldValue, err := session.Session.Get(field.Var)
+						if err != nil || oldValue != fieldValue {
+							value, err := session.Session.Set(field.Var, fieldValue)
+							if err != nil {
+								errString = fmt.Sprintf("Error for field %v: %v, aborting", field.Var, err.Error())
+								break
+							}
+							infoStrings = append(infoStrings, fmt.Sprintf("%s set to %s", field.Var, value))
+							gateway.DirtySessions = true
+						}
+					}
+				}
+
+				var elements []stanza.CommandElement
+				if errString != "" {
+					elements = append(elements, &stanza.Note{
+						Text: errString,
+						Type: stanza.CommandNoteTypeErr,
+					})
+				}
+				if warnString != "" {
+					elements = append(elements, &stanza.Note{
+						Text: warnString,
+						Type: stanza.CommandNoteTypeWarn,
+					})
+				}
+				for _, infoString := range infoStrings {
+					elements = append(elements, &stanza.Note{
+						Text: infoString,
+						Type: stanza.CommandNoteTypeInfo,
+					})
+				}
+
+				answer.Payload = &stanza.Command{
+					SessionId:       command.Node,
+					Node:            command.Node,
+					Status:          stanza.CommandStatusCompleted,
+					CommandElements: elements,
+				}
+			}
+		} else if !toOk && command.Node == "loginwizard" {
+			var session *telegram.Client
+			answer.Payload, cancelSend, session = loginWizardPayload(bare, form, resource)
+
+			log.Debugf("immediate loginwizard payload: %#v", answer.Payload)
+			if cancelSend {
+				go sendLoginWizardResponse(component, answer, session)
+			}
+		} else if toOk && command.Node == "botmenu" {
+			payload := &stanza.Command{
+				SessionId: command.Node,
+				Node:      command.Node,
+			}
+			answer.Payload = payload
+
+			if len(form.Fields) == 1 && form.Fields[0] != nil &&
+				form.Fields[0].Var == "command" && len(form.Fields[0].ValuesList) == 1 {
+				session, ok := sessions[bare]
+				if ok {
+					msgText := "/" + form.Fields[0].ValuesList[0]
+					session.LastBotCmdString = msgText
+					tgMessageId := session.ProcessOutgoingMessage(toId, msgText, iq.From, 0, 0, true)
+					if tgMessageId != 0 {
+						payload.Status = stanza.CommandStatusCompleted
+					} else {
+						setCommandPayloadError(payload, "Failed to send a bot command")
+					}
+				} else {
+					setCommandPayloadError(payload, "Session is lost")
+				}
+			} else {
+				setCommandPayloadError(payload, "Broken form")
+			}
+		} else {
 			// just for the case the client messed the order somehow
 			sort.Slice(form.Fields, func(i int, j int) bool {
 				iField := form.Fields[i]
@ -900,11 +1135,43 @@ func handleSetQueryCommand(s xmpp.Sender, iq *stanza.IQ, command *stanza.Command
 			}

 			cmdString = cmd.String()
+		}
 	} else {
 		if command.Action == "" || command.Action == stanza.CommandActionExecute {
 			cmd, ok := telegram.GetCommand(cmdType, command.Node)
 			if ok && len(cmd.Arguments) > 0 {
 				var fields []*stanza.Field
+				if command.Node == "config" {
+					session, ok := sessions[bare]
+					if ok {
+						for _, key := range persistence.ConfigKeys {
+							// no reason to display the item if carbons won't work
+							if key == "carbons" && gateway.MessageOutgoingPermissionVersion == 0 {
+								continue
+							}
+
+							value, err := session.Session.Get(key)
+							if err != nil {
+								log.Errorf("Achtung! Programming error in sessions with key %v", key)
+								continue
+							}
+
+							var fieldType string
+							if persistence.PropertyType(key) == persistence.PropertyTypeBool {
+								fieldType = stanza.FieldTypeBool
+							}
+
+							field := stanza.Field{
+								Var:        key,
+								Label:      key,
+								Type:       fieldType,
+								ValuesList: []string{value},
+							}
+							fields = append(fields, &field)
+							log.Debugf("field: %#v", field)
+						}
+					}
+				} else {
 					for i, arg := range cmd.Arguments {
 						var required *string
 						if i < cmd.RequiredArgs {
@ -958,6 +1225,7 @@ func handleSetQueryCommand(s xmpp.Sender, iq *stanza.IQ, command *stanza.Command
 						fields = append(fields, &field)
 						log.Debugf("field: %#v", field)
 					}
+				}
 				form := stanza.Form{
 					Type:         stanza.FormTypeForm,
 					Title:        command.Node,
@ -971,10 +1239,79 @@ func handleSetQueryCommand(s xmpp.Sender, iq *stanza.IQ, command *stanza.Command
 					CommandElements: []stanza.CommandElement{&form},
 				}
 				log.Debugf("form: %#v", form)
+			} else if !toOk && command.Node == "loginwizard" {
+				var session *telegram.Client
+				answer.Payload, cancelSend, session = loginWizardPayload(bare, nil, resource)
+
+				log.Debugf("immediate loginwizard payload: %#v", answer.Payload)
+				if cancelSend {
+					go sendLoginWizardResponse(component, answer, session)
+				}
+			} else if toOk && command.Node == "botmenu" {
+				session, ok := sessions[bare]
+
+				var link *telegram.BotLink
+				var commands []*telegram.BotCommand
+				var err error
+				if ok {
+					link, commands, err = session.GetBotMenu(toId)
+				}
+
+				payload := &stanza.Command{
+					SessionId: command.Node,
+					Node:      command.Node,
+				}
+				answer.Payload = payload
+
+				if !ok || err != nil {
+					setCommandPayloadError(payload, "Cannot retrieve commands")
+				} else {
+					if link != nil {
+						payload.Status = stanza.CommandStatusCompleted
+						payload.CommandElements = []stanza.CommandElement{
+							&stanza.Note{
+								Text: fmt.Sprintf("%v: %v", link.Description, link.Link),
+								Type: stanza.CommandNoteTypeInfo,
+							},
+						}
+					} else {
+						var options []stanza.Option
+						for _, cmd := range commands {
+							options = append(options, stanza.Option{
+								Label:      fmt.Sprintf("/%v — %v", cmd.Command, cmd.Description),
+								ValuesList: []string{cmd.Command},
+							})
+						}
+
+						dummyString := ""
+						field := stanza.Field{
+							Var:      "command",
+							Type:     stanza.FieldTypeListSingle,
+							Required: &dummyString,
+							Options:  options,
+						}
+						log.Debugf("field: %#v", field)
+
+						form := stanza.Form{
+							Type:   stanza.FormTypeForm,
+							Fields: []*stanza.Field{&field},
+						}
+						log.Debugf("form: %#v", form)
+
+						payload.Status = stanza.CommandStatusExecuting
+						payload.CommandElements = []stanza.CommandElement{&form}
+					}
+				}
 			} else {
 				cmdString = "/" + command.Node
 			}
 		} else if command.Action == stanza.CommandActionCancel {
+			if command.Node == "loginwizard" {
+				session, ok := sessions[bare]
+				if ok {
+					session.ProcessTransportCommand("/cancelauth", resource)
+				}
+			}
 			answer.Payload = &stanza.Command{
 				SessionId: command.Node,
 				Node:      command.Node,
@ -1018,7 +1355,7 @@ func handleSetQueryCommand(s xmpp.Sender, iq *stanza.IQ, command *stanza.Command

 	}

-	log.Debugf("command response: %#v", answer.Payload)
+	log.Debugf("command response: %#v %v", answer.Payload, cancelSend)
 }

 func iqAnswerSetError(answer *stanza.IQ, payload *extensions.QueryRegister, code int) {
@ -1061,6 +1398,15 @@ func iqAnswerSetError(answer *stanza.IQ, payload *extensions.QueryRegister, code
 	}
 }

+func setCommandPayloadError(payload *stanza.Command, err string) {
+	note := stanza.Note{
+		Text: err,
+		Type: stanza.CommandNoteTypeErr,
+	}
+	payload.Status = stanza.CommandStatusCompleted
+	payload.CommandElements = append(payload.CommandElements, &note)
+}
+
 func probeClientFeatures(jid string, component *xmpp.Component) {
 	id, err := uuid.NewRandom()
 	if err != nil {
@ -1123,8 +1469,8 @@ func sendPubSubAvatarNotifications(s xmpp.Sender, jid string, session *telegram.
 		return
 	}

-	for _, chatId := range session.ChatsKeys() {
-		chat, _, err := session.GetContactByID(chatId, nil)
+	for _, chatId := range session.OwnChatsKeys() {
+		chat, _, err := session.GetContactByID(chatId, nil, true)
 		if err != nil || chat == nil {
 			continue
 		}
@ -1134,7 +1480,8 @@ func sendPubSubAvatarNotifications(s xmpp.Sender, jid string, session *telegram.
 			continue
 		}

-		sha1, size := session.GetPhotoSha1AndSize(chat.Photo.Small, chat.Id)
+		sha1 := session.GetPhotoSha1(chat.Photo.Small, chat.Id)
+		size := session.GetPhotoSize(chat.Photo.Small)

 		gateway.SendPubSubAvatarNotification(component, jid, chat.Id, sha1, size)
 	}
--- a/xmpp/loginwizard.go
+++ b/xmpp/loginwizard.go
@ -0,0 +1,101 @@
+package xmpp
+
+import (
+	"fmt"
+
+	"dev.narayana.im/narayana/telegabber/telegram"
+	"dev.narayana.im/narayana/telegabber/xmpp/gateway"
+
+	log "github.com/sirupsen/logrus"
+	"gosrc.io/xmpp"
+	"gosrc.io/xmpp/stanza"
+)
+
+func loginWizardPayload(bare string, requestForm *stanza.Form, resource string) (payload *stanza.Command, cancelSend bool, returnSession *telegram.Client) {
+	payload = &stanza.Command{
+		SessionId: "loginwizard",
+		Node:      "loginwizard",
+	}
+
+	session, ok := sessions[bare]
+	if ok {
+		returnSession = session
+
+		if requestForm == nil {
+			session.StartLoginWizard(false)
+			cancelSend = true
+		} else {
+			if len(requestForm.Fields) != 1 {
+				setCommandPayloadError(payload, "Hey, don't tinker with the form!")
+				return
+			}
+			field := requestForm.Fields[0]
+			if field != nil {
+				if len(field.ValuesList) < 1 {
+					setCommandPayloadError(payload, "No value")
+					return
+				}
+				switch field.Var {
+				case "login", "code", "password":
+				default:
+					setCommandPayloadError(payload, "Unknown field")
+					return
+				}
+
+				session.StartLoginWizard(true)
+				response, success := session.ProcessTransportCommand(fmt.Sprintf("/%v %v", field.Var, field.ValuesList[0]), resource)
+				if !success {
+					setCommandPayloadError(payload, response)
+					session.StopLoginWizard()
+					return
+				}
+
+				cancelSend = true
+			}
+		}
+	} else {
+		setCommandPayloadError(payload, fmt.Sprintf("Session is not initialized, add the transport (%v) to contacts first", gateway.Jid.Bare()))
+	}
+
+	return
+}
+
+func sendLoginWizardResponse(component *xmpp.Component, answer *stanza.IQ, session *telegram.Client) {
+	payload := &stanza.Command{
+		SessionId: "loginwizard",
+		Node:      "loginwizard",
+	}
+
+	nextStage := "login"
+	if session != nil {
+		nextStage = session.GetLoginWizardNextStage()
+	}
+	log.Debugf("nextStage: %v", nextStage)
+
+	if nextStage == "cancel" {
+		setCommandPayloadError(payload, "Cancelled")
+		session.StopLoginWizard()
+	} else if nextStage == "success" {
+		payload.Status = stanza.CommandStatusCompleted
+		session.StopLoginWizard()
+	} else {
+		required := ""
+		form := stanza.Form{
+			Type:  stanza.FormTypeForm,
+			Title: "Login Wizard",
+			Fields: []*stanza.Field{
+				&stanza.Field{
+					Var:      nextStage,
+					Label:    nextStage,
+					Required: &required,
+				},
+			},
+		}
+		payload.Status = stanza.CommandStatusExecuting
+		payload.CommandElements = append(payload.CommandElements, &form)
+	}
+
+	answer.Payload = payload
+
+	gateway.ResumableSend(component, answer)
+}
Author	SHA1	Message	Date
Bohdan Horbeshko	bc5e8f1217	Crash hotfix for the ANNOYING PALOCHKA fix	2026-06-20 12:57:27 -04:00
Bohdan Horbeshko	1c160a8a13	Fix the annoying PALOCHKA	2026-06-04 20:04:35 -04:00
Bohdan Horbeshko	7d9f20d007	Support reply ID accounting for SFS uploads	2026-06-02 21:48:59 -04:00
Bohdan Horbeshko	eee277e36e	Track updated message ids for more reliable message edit check	2025-10-31 13:16:56 -04:00
Bohdan Horbeshko	5650850be9	Return text acknowledges for arbitrary commands	2025-10-27 18:21:49 -04:00
Bohdan Horbeshko	1d29aa4694	Generic online safety check for commands	2025-10-27 17:52:46 -04:00
Bohdan Horbeshko	e073ded9e4	Version 1.12.8	2025-10-19 13:07:16 -04:00
Bohdan Horbeshko	78a4305872	Respond to urn:xmpp:time (XEP-0202) queries	2025-10-18 16:42:40 -04:00
Bohdan Horbeshko	aaca93e66d	Respond to jabber:version (XEP-0092) queries	2025-10-10 07:44:44 -04:00
Bohdan Horbeshko	e7c6318e48	Add /cancelauth command && unsubscribe from chats more eagerly	2025-10-09 11:32:33 -04:00
Bohdan Horbeshko	140cf7fa4a	Keep two chat caches to avoid unnecessary presences	2025-09-16 08:15:42 -04:00
Bohdan Horbeshko	326c94973a	Treat incoming probe presence same as available only first time after transport restart	2025-09-13 17:01:09 -04:00
Bohdan Horbeshko	3fd49923a1	Safety limit for avatars	2025-06-07 18:02:46 -04:00
Bohdan Horbeshko	06964d832e	Get rid of edited message hash comparison in favour of EditDate check	2025-06-07 03:24:48 -04:00
Bohdan Horbeshko	5f4165ac13	Ignore prefix for OOB in channels too	2025-06-02 10:56:26 -04:00
Bohdan Horbeshko	68c3bece71	Apply hideids to carbons in groupchats	2025-05-05 17:54:56 -04:00
Bohdan Horbeshko	9378fa4991	Add /raw command to bypass bot commands	2025-04-30 19:55:34 -04:00
Bohdan Horbeshko	4414c147d8	Bot Menu via Ad-Hoc	2025-04-30 19:44:28 -04:00
Bohdan Horbeshko	3cac57e0f3	Fix password resetting	2025-04-17 19:22:02 -04:00
Bohdan Horbeshko	85846346d1	Login Wizard	2025-04-17 19:03:59 -04:00
Bohdan Horbeshko	0368b8cad8	Ad-Hoc config editor	2025-03-22 18:11:45 -04:00