feat: add --topic and --all-topics flags to read command for forum groups

Author: dgrr

src/app/mod.rs

@@ -150,4 +150,55 @@ impl App {
             chat_id
         );
     }
+
+    /// Mark all forum topics in a chat as read.
+    /// Returns the number of topics marked as read.
+    pub async fn mark_read_all_topics(&self, chat_id: i64) -> Result<usize> {
+        let peer_ref = self.resolve_peer_ref_for_topics(chat_id).await?;
+        let input_peer: tl::enums::InputPeer = peer_ref.into();
+
+        // First, fetch all topics
+        let request = tl::functions::messages::GetForumTopics {
+            peer: input_peer.clone(),
+            q: None,
+            offset_date: 0,
+            offset_id: 0,
+            offset_topic: 0,
+            limit: 100,
+        };
+
+        let result = self
+            .tg
+            .client
+            .invoke(&request)
+            .await
+            .with_context(|| format!("Failed to fetch forum topics for chat {}", chat_id))?;
+
+        let topics = match result {
+            tl::enums::messages::ForumTopics::Topics(t) => t.topics,
+        };
+
+        let mut count = 0;
+        for topic_enum in topics {
+            if let tl::enums::ForumTopic::Topic(topic) = topic_enum {
+                // Mark this topic as read
+                let read_request = tl::functions::messages::ReadDiscussion {
+                    peer: input_peer.clone(),
+                    msg_id: topic.id,
+                    read_max_id: topic.top_message,
+                };
+
+                match self.tg.client.invoke(&read_request).await {
+                    Ok(_) => {
+                        count += 1;
+                    }
+                    Err(e) => {
+                        log::warn!("Failed to mark topic {} as read: {}", topic.id, e);
+                    }
+                }
+            }
+        }
+
+        Ok(count)
+    }
 }

src/app/send.rs

@@ -387,13 +387,14 @@ impl App {
         Ok(())
     }
 
-    /// Forward a message from one chat to another.
+    /// Forward a message from one chat to another (optionally to a specific topic).
     /// Returns the new message ID in the destination chat.
     pub async fn forward_message(
         &self,
         from_chat_id: i64,
         msg_id: i64,
         to_chat_id: i64,
+        to_topic_id: Option<i32>,
     ) -> Result<i64> {
         let from_peer = self.resolve_peer_ref(from_chat_id).await?;
         let to_peer = self.resolve_peer_ref(to_chat_id).await?;
@@ -415,7 +416,7 @@ impl App {
             id: vec![msg_id as i32],
             random_id: vec![random_id],
             to_peer: to_input_peer,
-            top_msg_id: None,
+            top_msg_id: to_topic_id,
             schedule_date: None,
             send_as: None,
             quick_reply_shortcut: None,
@@ -434,14 +435,29 @@ impl App {
         Ok(new_msg_id)
     }
 
-    /// Mark a chat as read.
-    pub async fn mark_read(&mut self, chat_id: i64) -> Result<()> {
+    /// Mark a chat (or topic in a forum) as read.
+    pub async fn mark_read(&mut self, chat_id: i64, topic_id: Option<i32>) -> Result<()> {
         let peer_ref = self.resolve_peer_ref(chat_id).await?;
-        self.tg
-            .client
-            .mark_as_read(peer_ref)
-            .await
-            .context(format!("Failed to mark chat {} as read", chat_id))?;
+
+        if let Some(tid) = topic_id {
+            // For forum topics, use ReadDiscussion to mark the topic as read
+            let input_peer: tl::enums::InputPeer = peer_ref.into();
+            let request = tl::functions::messages::ReadDiscussion {
+                peer: input_peer,
+                msg_id: tid,
+                read_max_id: i32::MAX,
+            };
+            self.tg.client.invoke(&request).await.context(format!(
+                "Failed to mark topic {} in chat {} as read",
+                tid, chat_id
+            ))?;
+        } else {
+            self.tg
+                .client
+                .mark_as_read(peer_ref)
+                .await
+                .context(format!("Failed to mark chat {} as read", chat_id))?;
+        }
         Ok(())
     }
 
@@ -1026,33 +1042,63 @@ impl App {
         Ok(())
     }
 
-    /// Send typing indicator to a chat.
-    pub async fn set_typing(&self, chat_id: i64) -> Result<()> {
+    /// Send typing indicator to a chat (or topic in a forum).
+    pub async fn set_typing(&self, chat_id: i64, topic_id: Option<i32>) -> Result<()> {
         let peer_ref = self.resolve_peer_ref(chat_id).await?;
-        self.tg
-            .client
-            .action(peer_ref)
-            .oneshot(SendMessageAction::SendMessageTypingAction)
-            .await
-            .context(format!(
-                "Failed to set typing indicator in chat {}",
-                chat_id
+
+        if let Some(tid) = topic_id {
+            // For forum topics, use raw TL to set typing with top_msg_id
+            let input_peer: tl::enums::InputPeer = peer_ref.into();
+            let request = tl::functions::messages::SetTyping {
+                peer: input_peer,
+                top_msg_id: Some(tid),
+                action: SendMessageAction::SendMessageTypingAction,
+            };
+            self.tg.client.invoke(&request).await.context(format!(
+                "Failed to set typing indicator in topic {} of chat {}",
+                tid, chat_id
             ))?;
+        } else {
+            self.tg
+                .client
+                .action(peer_ref)
+                .oneshot(SendMessageAction::SendMessageTypingAction)
+                .await
+                .context(format!(
+                    "Failed to set typing indicator in chat {}",
+                    chat_id
+                ))?;
+        }
         Ok(())
     }
 
-    /// Cancel typing indicator in a chat.
-    pub async fn cancel_typing(&self, chat_id: i64) -> Result<()> {
+    /// Cancel typing indicator in a chat (or topic in a forum).
+    pub async fn cancel_typing(&self, chat_id: i64, topic_id: Option<i32>) -> Result<()> {
         let peer_ref = self.resolve_peer_ref(chat_id).await?;
-        self.tg
-            .client
-            .action(peer_ref)
-            .cancel()
-            .await
-            .context(format!(
-                "Failed to cancel typing indicator in chat {}",
-                chat_id
+
+        if let Some(tid) = topic_id {
+            // For forum topics, use raw TL to cancel typing with top_msg_id
+            let input_peer: tl::enums::InputPeer = peer_ref.into();
+            let request = tl::functions::messages::SetTyping {
+                peer: input_peer,
+                top_msg_id: Some(tid),
+                action: SendMessageAction::SendMessageCancelAction,
+            };
+            self.tg.client.invoke(&request).await.context(format!(
+                "Failed to cancel typing indicator in topic {} of chat {}",
+                tid, chat_id
             ))?;
+        } else {
+            self.tg
+                .client
+                .action(peer_ref)
+                .cancel()
+                .await
+                .context(format!(
+                    "Failed to cancel typing indicator in chat {}",
+                    chat_id
+                ))?;
+        }
         Ok(())
     }
 }

src/cmd/messages.rs

@@ -65,6 +65,9 @@ pub enum MessagesCommand {
         /// Chat ID filter
         #[arg(long)]
         chat: Option<i64>,
+        /// Topic ID (for forum groups)
+        #[arg(long)]
+        topic: Option<i32>,
         /// Sender ID filter
         #[arg(long)]
         from: Option<i64>,
@@ -161,6 +164,9 @@ pub enum MessagesCommand {
         /// Destination chat ID
         #[arg(long)]
         to: i64,
+        /// Destination topic ID (for forum groups)
+        #[arg(long)]
+        topic: Option<i32>,
     },
     /// Edit a message's text
     Edit {
@@ -323,6 +329,7 @@ pub async fn run(cli: &Cli, cmd: &MessagesCommand) -> Result<()> {
         MessagesCommand::Search {
             query,
             chat,
+            topic,
             from,
             limit,
             media_type,
@@ -334,6 +341,7 @@ pub async fn run(cli: &Cli, cmd: &MessagesCommand) -> Result<()> {
                 .search_messages(store::SearchMessagesParams {
                     query: query.clone(),
                     chat_id: *chat,
+                    topic_id: *topic,
                     from_id: *from,
                     limit: *limit,
                     media_type: media_type.clone(),
@@ -469,20 +477,34 @@ pub async fn run(cli: &Cli, cmd: &MessagesCommand) -> Result<()> {
                 );
             }
         }
-        MessagesCommand::Forward { chat, id, to } => {
+        MessagesCommand::Forward {
+            chat,
+            id,
+            to,
+            topic,
+        } => {
             // Forward requires network access
             let app = App::new(cli).await?;
 
-            let new_msg_id = app.forward_message(*chat, *id, *to).await?;
+            let new_msg_id = app.forward_message(*chat, *id, *to, *topic).await?;
 
             if cli.json {
-                out::write_json(&serde_json::json!({
+                let mut json = serde_json::json!({
                     "forwarded": true,
                     "from_chat": chat,
                     "message_id": id,
                     "to_chat": to,
                     "new_message_id": new_msg_id,
-                }))?;
+                });
+                if let Some(topic_id) = topic {
+                    json["to_topic"] = serde_json::json!(topic_id);
+                }
+                out::write_json(&json)?;
+            } else if let Some(topic_id) = topic {
+                println!(
+                    "Forwarded message {} from {} to {} topic {} (new ID: {})",
+                    id, chat, to, topic_id, new_msg_id
+                );
             } else {
                 println!(
                     "Forwarded message {} from {} to {} (new ID: {})",

src/cmd/read.rs

@@ -13,40 +13,83 @@ pub struct ReadArgs {
     /// Message ID (mark up to this message as read)
     #[arg(long)]
     pub message: Option<i64>,
+
+    /// Topic ID (for forum groups - marks a specific topic as read)
+    #[arg(long)]
+    pub topic: Option<i32>,
+
+    /// Mark all topics as read (for forum groups)
+    #[arg(long)]
+    pub all_topics: bool,
 }
 
 pub async fn run(cli: &Cli, args: &ReadArgs) -> Result<()> {
     let store_dir = cli.store_dir();
 
-    // Try socket first
-    if crate::app::socket::is_socket_available(&store_dir) {
-        let resp = crate::app::socket::send_request(
-            &store_dir,
-            crate::app::socket::SocketRequest::MarkRead {
-                chat: args.chat,
-                message: args.message,
-            },
-        )
-        .await?;
-
-        if resp.ok {
-            if cli.json {
-                out::write_json(&serde_json::json!({ "marked_read": true }))?;
-            } else {
-                println!("Marked as read.");
+    // Validate: --topic and --all-topics are mutually exclusive
+    if args.topic.is_some() && args.all_topics {
+        anyhow::bail!("Cannot use both --topic and --all-topics at the same time");
+    }
+
+    // Try socket first (but only for simple chat read, not topics)
+    if args.topic.is_none() && !args.all_topics {
+        if crate::app::socket::is_socket_available(&store_dir) {
+            let resp = crate::app::socket::send_request(
+                &store_dir,
+                crate::app::socket::SocketRequest::MarkRead {
+                    chat: args.chat,
+                    message: args.message,
+                },
+            )
+            .await?;
+
+            if resp.ok {
+                if cli.json {
+                    out::write_json(&serde_json::json!({ "marked_read": true }))?;
+                } else {
+                    println!("Marked as read.");
+                }
+                return Ok(());
             }
-            return Ok(());
         }
     }
 
     // Fallback: direct connection
     let mut app = App::new(cli).await?;
-    app.mark_read(args.chat).await?;
 
-    if cli.json {
-        out::write_json(&serde_json::json!({ "marked_read": true }))?;
+    if args.all_topics {
+        // Mark all topics as read
+        let count = app.mark_read_all_topics(args.chat).await?;
+
+        if cli.json {
+            out::write_json(&serde_json::json!({
+                "marked_read": true,
+                "topics_count": count
+            }))?;
+        } else {
+            println!("Marked {} topics as read.", count);
+        }
+    } else if let Some(topic_id) = args.topic {
+        // Mark a specific topic as read
+        app.mark_read(args.chat, Some(topic_id)).await?;
+
+        if cli.json {
+            out::write_json(&serde_json::json!({
+                "marked_read": true,
+                "topic_id": topic_id
+            }))?;
+        } else {
+            println!("Marked topic {} as read.", topic_id);
+        }
     } else {
-        println!("Marked as read.");
+        // Mark the whole chat as read (or a single topic if --topic was given but not --all-topics)
+        app.mark_read(args.chat, None).await?;
+
+        if cli.json {
+            out::write_json(&serde_json::json!({ "marked_read": true }))?;
+        } else {
+            println!("Marked as read.");
+        }
     }
 
     Ok(())