feat: add Telegram forum topics support (v0.4.0)

Add full support for Telegram forum-style supergroups with topics:
- Detect forum groups via is_forum flag on both Peer::Group and Peer::Channel
- New get_forum_topics command using raw TL messages.GetForumTopics API
- Topic-aware get_messages (via messages.GetReplies) and send_message (via reply_to)
- TopicList component with colored icons, pinned/closed badges, unread counts
- MainLayout integration: chat → topic list → topic messages navigation
- Forum badge icon in chat list for forum groups
- SQLite migration adding is_forum column
- i18n translations (EN + RU)

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: suenot

package.json

@@ -1,7 +1,7 @@
 {
   "name": "vasyapp",
   "private": true,
-  "version": "0.3.0",
+  "version": "0.4.0",
   "type": "module",
   "scripts": {
     "dev": "vite",

src-tauri/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "telegram-client"
-version = "0.2.0"
+version = "0.4.0"
 description = "A Tauri App"
 authors = ["you"]
 edition = "2021"

src-tauri/src/commands/chats.rs

@@ -24,6 +24,7 @@ pub struct Chat {
     pub chat_type: String, // "user", "group", "channel"
     pub last_message: Option<String>,
     pub avatar_path: Option<String>,
+    pub is_forum: bool,
 }
 
 #[derive(Debug, Clone, Serialize)]
@@ -61,6 +62,7 @@ pub async fn get_cached_chats(
             chat_type: r.chat_type,
             last_message: r.last_message,
             avatar_path: r.avatar_path,
+            is_forum: r.is_forum,
         })
         .collect();
 
@@ -114,17 +116,24 @@ pub async fn start_loading_chats(
     while let Some(dialog) = dialogs.next().await.map_err(|e| format!("Failed to get dialogs: {}", e))? {
         let peer = &dialog.peer;
 
-        let chat_type = match peer {
-            Peer::User(_) => "user",
-            Peer::Group(_) => "group",
-            Peer::Channel(_) => "channel",
+        let (chat_type, is_forum) = match peer {
+            Peer::User(_) => ("user", false),
+            Peer::Group(g) => {
+                // Megagroups (supergroups) with forum flag enabled
+                let forum = match &g.raw {
+                    grammers_tl_types::enums::Chat::Channel(ch) => ch.forum,
+                    _ => false,
+                };
+                ("group", forum)
+            },
+            Peer::Channel(c) => ("channel", c.raw.forum),
         };
 
         let title = peer.name().unwrap_or("Unknown").to_string();
         let username = match peer {
             Peer::User(u) => u.username().map(|s| s.to_string()),
             Peer::Channel(c) => c.username().map(|s| s.to_string()),
-            _ => None,
+            Peer::Group(g) => g.username().map(|s| s.to_string()),
         };
 
         let chat_id = PeerRef::from(peer).id.bot_api_dialog_id();
@@ -164,6 +173,7 @@ pub async fn start_loading_chats(
             chat_type: chat_type.to_string(),
             last_message: last_message_text.clone(),
             avatar_path: cached_avatar.clone(),
+            is_forum,
         };
 
         // EMIT IMMEDIATELY — no waiting for avatar download or DB save
@@ -186,6 +196,7 @@ pub async fn start_loading_chats(
             let last_message_text = last_message_text.clone();
             let cached_avatar = cached_avatar.clone();
             let semaphore = Arc::clone(&avatar_semaphore);
+            let is_forum = is_forum;
 
             tokio::spawn(async move {
                 // Download avatar if not cached (rate-limited by semaphore)
@@ -213,6 +224,7 @@ pub async fn start_loading_chats(
                         avatar_path: avatar_path.clone(),
                         last_message: last_message_text.clone(),
                         unread_count: 0,
+                        is_forum,
                     };
                     if let Err(e) = storage.save_chat(&record).await {
                         tracing::warn!(chat_id = chat_id, error = %e, "Failed to save chat to storage");
@@ -259,17 +271,23 @@ pub async fn get_chats(
 
     while let Some(dialog) = dialogs.next().await.map_err(|e| format!("Failed to get dialogs: {}", e))? {
         let peer = &dialog.peer;
-        let chat_type = match peer {
-            Peer::User(_) => "user",
-            Peer::Group(_) => "group",
-            Peer::Channel(_) => "channel",
+        let (chat_type, is_forum) = match peer {
+            Peer::User(_) => ("user", false),
+            Peer::Group(g) => {
+                let forum = match &g.raw {
+                    grammers_tl_types::enums::Chat::Channel(ch) => ch.forum,
+                    _ => false,
+                };
+                ("group", forum)
+            },
+            Peer::Channel(c) => ("channel", c.raw.forum),
         };
 
         let title = peer.name().unwrap_or("Unknown").to_string();
         let username = match peer {
             Peer::User(u) => u.username().map(|s| s.to_string()),
             Peer::Channel(c) => c.username().map(|s| s.to_string()),
-            _ => None,
+            Peer::Group(g) => g.username().map(|s| s.to_string()),
         };
 
         let chat_id = PeerRef::from(peer).id.bot_api_dialog_id();
@@ -283,6 +301,7 @@ pub async fn get_chats(
             chat_type: chat_type.to_string(),
             last_message: None,
             avatar_path,
+            is_forum,
         });
     }
 

src-tauri/src/commands/messages.rs

@@ -55,19 +55,21 @@ fn extract_media_info(msg: &GrammersMessage) -> Option<Vec<MediaInfo>> {
     })
 }
 
-/// Get messages from a chat
+/// Get messages from a chat (or from a specific forum topic when topic_id is provided)
 #[tauri::command]
 pub async fn get_messages(
     account_id: String,
     chat_id: i64,
     offset_id: Option<i32>,
     limit: Option<usize>,
+    topic_id: Option<i32>,
     state: State<'_, Arc<RwLock<AppState>>>,
 ) -> Result<Vec<Message>, String> {
     tracing::info!(
         account_id = %account_id,
         chat_id = chat_id,
         offset_id = ?offset_id,
+        topic_id = ?topic_id,
         "Getting messages"
     );
 
@@ -84,8 +86,66 @@ pub async fn get_messages(
     }; // state_guard dropped here
 
     let chat = resolve_peer(&wrapper, chat_id).await?;
-
     let limit = limit.unwrap_or(50);
+
+    // For forum topics, use messages.getReplies with msg_id = topic_id
+    if let Some(tid) = topic_id {
+        let input_peer: grammers_tl_types::enums::InputPeer = PeerRef::from(&chat).into();
+        let request = grammers_tl_types::functions::messages::GetReplies {
+            peer: input_peer,
+            msg_id: tid,
+            offset_id: offset_id.unwrap_or(0),
+            offset_date: 0,
+            add_offset: 0,
+            limit: limit as i32,
+            max_id: 0,
+            min_id: 0,
+            hash: 0,
+        };
+
+        let result = wrapper
+            .client
+            .invoke(&request)
+            .await
+            .map_err(|e| format!("Failed to get topic messages: {}", e))?;
+
+        let raw_messages = match result {
+            grammers_tl_types::enums::messages::Messages::Messages(m) => m.messages,
+            grammers_tl_types::enums::messages::Messages::Slice(m) => m.messages,
+            grammers_tl_types::enums::messages::Messages::ChannelMessages(m) => m.messages,
+            grammers_tl_types::enums::messages::Messages::NotModified(_) => Vec::new(),
+        };
+
+        let messages: Vec<Message> = raw_messages
+            .into_iter()
+            .filter_map(|m| {
+                match m {
+                    grammers_tl_types::enums::Message::Message(msg) => {
+                        let from_user_id = msg.from_id.as_ref().map(|p| match p {
+                            grammers_tl_types::enums::Peer::User(u) => u.user_id,
+                            grammers_tl_types::enums::Peer::Chat(c) => c.chat_id,
+                            grammers_tl_types::enums::Peer::Channel(c) => c.channel_id,
+                        });
+                        Some(Message {
+                            id: msg.id,
+                            chat_id,
+                            from_user_id,
+                            text: if msg.message.is_empty() { None } else { Some(msg.message) },
+                            date: msg.date as i64,
+                            is_outgoing: msg.out,
+                            media: None, // Raw TL media parsing would be complex; keep simple for now
+                        })
+                    }
+                    _ => None,
+                }
+            })
+            .collect();
+
+        tracing::info!(count = messages.len(), chat_id = chat_id, topic_id = tid, "Topic messages loaded");
+        return Ok(messages);
+    }
+
+    // Regular messages (no topic)
     let mut messages_iter = wrapper.client.iter_messages(&chat);
 
     if let Some(offset) = offset_id {
@@ -193,15 +253,16 @@ pub async fn search_messages(
     Ok(messages)
 }
 
-/// Send a message to a chat
+/// Send a message to a chat (or to a specific forum topic when topic_id is provided)
 #[tauri::command]
 pub async fn send_message(
     account_id: String,
     chat_id: i64,
     text: String,
+    topic_id: Option<i32>,
     state: State<'_, Arc<RwLock<AppState>>>,
 ) -> Result<Message, String> {
-    tracing::info!(account_id = %account_id, chat_id = chat_id, "Sending message");
+    tracing::info!(account_id = %account_id, chat_id = chat_id, topic_id = ?topic_id, "Sending message");
 
     if text.trim().is_empty() {
         return Err("Message text cannot be empty".to_string());
@@ -221,9 +282,16 @@ pub async fn send_message(
 
     let chat = resolve_peer(&wrapper, chat_id).await?;
 
+    // For forum topics, use InputMessage with reply_to set to topic_id
+    let input_msg = if let Some(tid) = topic_id {
+        grammers_client::InputMessage::new().text(&text).reply_to(Some(tid))
+    } else {
+        grammers_client::InputMessage::new().text(&text)
+    };
+
     let sent_message = wrapper
         .client
-        .send_message(&chat, text.clone())
+        .send_message(&chat, input_msg)
         .await
         .map_err(|e| format!("Failed to send message: {}", e))?;
 

src-tauri/src/commands/mod.rs

@@ -12,6 +12,7 @@ pub mod peer_resolve;
 pub mod flood_wait;
 pub mod stt;
 pub mod folders;
+pub mod topics;
 
 pub use auth::*;
 pub use settings::*;
@@ -20,3 +21,4 @@ pub use messages::*;
 pub use media::*;
 pub use stt::*;
 pub use folders::*;
+pub use topics::*;

src-tauri/src/commands/topics.rs

@@ -0,0 +1,95 @@
+//! Forum topics commands
+//!
+//! Retrieves topics from Telegram forum supergroups using raw TL API calls.
+
+use std::sync::Arc;
+use tauri::State;
+use tokio::sync::RwLock;
+use serde::{Deserialize, Serialize};
+use grammers_session::defs::PeerRef;
+use grammers_tl_types as tl;
+
+use crate::AppState;
+use super::peer_resolve::resolve_peer;
+
+#[derive(Debug, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ForumTopic {
+    pub id: i32,
+    pub title: String,
+    pub icon_color: i32,
+    pub icon_emoji_id: Option<i64>,
+    pub unread_count: i32,
+    pub top_message: i32,
+    pub is_pinned: bool,
+    pub is_closed: bool,
+}
+
+/// Get forum topics for a forum supergroup
+#[tauri::command]
+pub async fn get_forum_topics(
+    account_id: String,
+    chat_id: i64,
+    state: State<'_, Arc<RwLock<AppState>>>,
+) -> Result<Vec<ForumTopic>, String> {
+    tracing::info!(
+        account_id = %account_id,
+        chat_id = chat_id,
+        "Getting forum topics"
+    );
+
+    let wrapper = {
+        let state_guard = state.read().await;
+        let client_manager = state_guard
+            .client_manager
+            .as_ref()
+            .ok_or("Client manager not initialized")?;
+        client_manager
+            .get_client(&account_id)
+            .await
+            .ok_or("Client not found for this account")?
+    };
+
+    let peer = resolve_peer(&wrapper, chat_id).await?;
+    let input_peer: tl::enums::InputPeer = PeerRef::from(&peer).into();
+
+    let request = tl::functions::messages::GetForumTopics {
+        peer: input_peer,
+        q: None,
+        offset_date: 0,
+        offset_id: 0,
+        offset_topic: 0,
+        limit: 100,
+    };
+
+    let result = wrapper
+        .client
+        .invoke(&request)
+        .await
+        .map_err(|e| format!("Failed to get forum topics: {}", e))?;
+
+    let tl::enums::messages::ForumTopics::Topics(forum_topics) = result;
+
+    let topics: Vec<ForumTopic> = forum_topics
+        .topics
+        .into_iter()
+        .filter_map(|topic| {
+            match topic {
+                tl::enums::ForumTopic::Topic(t) => Some(ForumTopic {
+                    id: t.id,
+                    title: t.title,
+                    icon_color: t.icon_color,
+                    icon_emoji_id: t.icon_emoji_id,
+                    unread_count: t.unread_count,
+                    top_message: t.top_message,
+                    is_pinned: t.pinned,
+                    is_closed: t.closed,
+                }),
+                tl::enums::ForumTopic::Deleted(_) => None,
+            }
+        })
+        .collect();
+
+    tracing::info!(count = topics.len(), chat_id = chat_id, "Forum topics loaded");
+    Ok(topics)
+}

src-tauri/src/lib.rs

@@ -74,6 +74,7 @@ pub fn run() {
             commands::save_tabs,
             commands::get_storage_mode,
             commands::set_storage_mode,
+            commands::get_forum_topics,
         ])
         .setup(|app| {
             let app_dir = app