chat_sdk-telegram 1.0.1 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c9b1e05e9da55df58039cc8861917f9d91bcc0bbc8391e0863c1ab623331e83b
-  data.tar.gz: 9e41b3269dc1116e2bc7169b146770337e8f9bbb6020b85f7f36c575828cf678
+  metadata.gz: dd12f1353b787c17a0d76a18f868f68851c4b64fb6735075f56c478e8caa0be6
+  data.tar.gz: f570ad027ae3a715268b64cf817743cd74278da097ddfa52ece098baeb18c5bc
 SHA512:
-  metadata.gz: c5a3fb292395624ea3f812ff2c48c92a8c700ab092124c2c8b5ed5047c901191d0a1bf5b4dea05fcca7a20d02b48aa935ce5cef2ec479c5df0706972b5fc0e2a
-  data.tar.gz: 9843eee8e48fab1a345487035beac68a014bc558e343346dc1cfe6a170f7799b9170f9cff2e10d9bc8fdb738c4cc73fa118731558508baf8970509e54aeea3e2
+  metadata.gz: b0814d842b005c420a39dc7f2c06fa9fe9b9609c283947b6669de9dfb73d0d628204850ee15047f1fc44f7bd3fc9003d8c517d2830f2a41e8ad5e30566d08686
+  data.tar.gz: 303379f0c56a05e2a11b82b3225a64f51791bd3d439ad55750015568afc4b3df955b66f376fd294b8d2d4c6187b89986529ff42c51d3c7fc6c13998f55681cdd

data/lib/chat_sdk/telegram/adapter.rb

@@ -6,19 +6,29 @@ module ChatSDK
   module Telegram
     class Adapter < ChatSDK::Adapter::Base
       capabilities :edit_messages, :delete_messages, :reactions, :file_uploads,
-        :typing_indicator, :streaming_edit, :direct_messages
+        :typing_indicator, :streaming_edit, :direct_messages, :replies
 
       attr_reader :client
 
-      def initialize(bot_token: nil, secret_token: nil, bot_username: nil)
+      def initialize(bot_token: nil, secret_token: nil, bot_username: nil, allowed_user_ids: nil, allow_unverified_webhooks: nil,
+        mention_on_reply: false)
         @bot_token = bot_token || ENV["TELEGRAM_BOT_TOKEN"]
         @secret_token = secret_token || ENV["TELEGRAM_WEBHOOK_SECRET_TOKEN"]
         @bot_username = bot_username || ENV["TELEGRAM_BOT_USERNAME"]
+        @mention_on_reply = mention_on_reply
+        configured_user_ids = allowed_user_ids || ENV["TELEGRAM_ALLOWED_USER_IDS"]&.split(",")
+        @allowed_user_ids = configured_user_ids&.map(&:to_s)&.to_set
+        @allow_unverified_webhooks = if allow_unverified_webhooks.nil?
+          ENV["TELEGRAM_ALLOW_UNVERIFIED_WEBHOOKS"] == "true"
+        else
+          allow_unverified_webhooks
+        end
 
         raise ChatSDK::ConfigurationError, "Telegram bot_token required" unless @bot_token
 
         @client = ApiClient.new(@bot_token)
         @renderer = KeyboardRenderer.new
+        @format_converter = FormatConverter.new
       end
 
       def name
@@ -27,7 +37,12 @@ module ChatSDK
 
       # Inbound
       def verify_request!(rack_request)
-        return true unless @secret_token
+        return true if !@secret_token && @allow_unverified_webhooks
+
+        unless @secret_token
+          raise ChatSDK::SignatureVerificationError,
+            "Telegram secret_token required; set allow_unverified_webhooks: true to explicitly disable verification"
+        end
 
         header_token = rack_request.get_header("HTTP_X_TELEGRAM_BOT_API_SECRET_TOKEN")
 
@@ -48,7 +63,9 @@ module ChatSDK
 
       def parse_events(rack_request)
         payload = read_json_body(rack_request)
-        EventParser.parse(payload, bot_username: @bot_username)
+        return [] unless allowed_user?(payload)
+
+        EventParser.parse(payload, bot_username: @bot_username, mention_on_reply: @mention_on_reply)
       rescue JSON::ParserError
         []
       end
@@ -67,7 +84,19 @@ module ChatSDK
         parse_telegram_message(result, channel_id)
       end
 
-      def edit_message(channel_id:, message_id:, message:)
+      def reply_message(channel_id:, message_id:, message:, thread_id: nil)
+        text, reply_markup = prepare_message_payload(message)
+        result = @client.send_message(
+          chat_id: channel_id,
+          text: text,
+          reply_markup: reply_markup,
+          reply_to_message_id: message_id
+        )
+
+        parse_telegram_message(result, channel_id)
+      end
+
+      def edit_message(channel_id:, message_id:, message:, **_options)
         text, reply_markup = prepare_message_payload(message)
 
         @client.edit_message_text(
@@ -78,7 +107,7 @@ module ChatSDK
         )
       end
 
-      def delete_message(channel_id:, message_id:)
+      def delete_message(channel_id:, message_id:, **_options)
         @client.delete_message(chat_id: channel_id, message_id: message_id)
       end
 
@@ -92,7 +121,7 @@ module ChatSDK
         )
       end
 
-      def add_reaction(channel_id:, message_id:, emoji:)
+      def add_reaction(channel_id:, message_id:, emoji:, **_options)
         @client.set_message_reaction(
           chat_id: channel_id,
           message_id: message_id,
@@ -100,7 +129,7 @@ module ChatSDK
         )
       end
 
-      def remove_reaction(channel_id:, message_id:, emoji:) # rubocop:disable Lint/UnusedMethodArgument
+      def remove_reaction(channel_id:, message_id:, emoji:, **_options) # rubocop:disable Lint/UnusedMethodArgument
         @client.set_message_reaction(
           chat_id: channel_id,
           message_id: message_id,
@@ -125,7 +154,7 @@ module ChatSDK
         user_id
       end
 
-      def start_typing(channel_id:, thread_id: nil) # rubocop:disable Lint/UnusedMethodArgument
+      def start_typing(channel_id:, thread_id: nil, message_id: nil) # rubocop:disable Lint/UnusedMethodArgument
         @client.send_chat_action(chat_id: channel_id, action: "typing")
       end
 
@@ -150,7 +179,9 @@ module ChatSDK
           updates = updates.is_a?(Array) ? updates : []
           updates.each do |update|
             offset = update["update_id"] + 1
-            events = EventParser.parse(update, bot_username: @bot_username)
+            next unless allowed_user?(update)
+
+            events = EventParser.parse(update, bot_username: @bot_username, mention_on_reply: @mention_on_reply)
             events.each { |event| block.call(event) }
           end
         end
@@ -158,6 +189,18 @@ module ChatSDK
 
       private
 
+      def allowed_user?(payload)
+        return true unless @allowed_user_ids
+
+        user_id = payload.dig("callback_query", "from", "id") ||
+          payload.dig("message_reaction", "user", "id") ||
+          payload.dig("message", "from", "id") ||
+          payload.dig("edited_message", "from", "id") ||
+          payload.dig("channel_post", "from", "id") ||
+          payload.dig("edited_channel_post", "from", "id")
+        user_id && @allowed_user_ids.include?(user_id.to_s)
+      end
+
       def prepare_message_payload(message)
         msg = ChatSDK::PostableMessage.from(message)
         text = msg.text || msg.card&.fallback_text || ""
@@ -167,7 +210,7 @@ module ChatSDK
           text = rendered[:text] if rendered[:text] && !rendered[:text].empty?
           reply_markup = rendered[:reply_markup]
         end
-        [text, reply_markup]
+        [@format_converter.truncate_markdown_v2(text, 4096), reply_markup]
       end
 
       def parse_telegram_message(data, channel_id)

data/lib/chat_sdk/telegram/event_parser.rb

@@ -4,7 +4,7 @@ module ChatSDK
   module Telegram
     class EventParser
       class << self
-        def parse(payload, bot_username: nil)
+        def parse(payload, bot_username: nil, mention_on_reply: false)
           return [] unless payload.is_a?(Hash)
 
           if payload["callback_query"]
@@ -12,7 +12,7 @@ module ChatSDK
           elsif payload["message_reaction"]
             parse_message_reaction(payload["message_reaction"])
           elsif payload["message"]
-            parse_message(payload["message"], bot_username: bot_username)
+            parse_message(payload["message"], bot_username: bot_username, mention_on_reply: mention_on_reply)
           else
             []
           end
@@ -20,7 +20,7 @@ module ChatSDK
 
         private
 
-        def parse_message(message, bot_username: nil)
+        def parse_message(message, bot_username: nil, mention_on_reply: false)
           return parse_bot_command(message, extract_user(message), message.dig("chat", "id")&.to_s, resolve_thread_id(message)) if bot_command?(message)
 
           user = extract_user(message)
@@ -28,6 +28,7 @@ module ChatSDK
           chat_type = message.dig("chat", "type")
           text = message["text"] || ""
           thread_id = resolve_thread_id(message)
+          reply_mention = reply_to_bot?(message, bot_username, mention_on_reply)
 
           msg = ChatSDK::Message.new(
             id: message["message_id"]&.to_s,
@@ -36,10 +37,12 @@ module ChatSDK
             thread_id: thread_id,
             channel_id: chat_id,
             platform: :telegram,
+            is_mention: reply_mention ? true : nil,
+            reply_to: build_reply_to(message["reply_to_message"], chat_id),
             raw: message
           )
 
-          event_class = if mention?(text, bot_username)
+          event_class = if mention?(text, bot_username) || reply_mention
             ChatSDK::Events::Mention
           elsif chat_type == "private"
             ChatSDK::Events::DirectMessage
@@ -145,7 +148,40 @@ module ChatSDK
         def mention?(text, bot_username)
           return false unless bot_username
 
-          text.include?("@#{bot_username}")
+          /(?<!\w)@#{Regexp.escape(bot_username)}(?![\w-])/i.match?(text)
+        end
+
+        def reply_to_bot?(message, bot_username, mention_on_reply)
+          return false unless mention_on_reply && bot_username
+
+          reply = message["reply_to_message"] || {}
+          bot_user = reply["from"] || {}
+          return false unless bot_user["is_bot"] && bot_user["username"].to_s.casecmp?(bot_username)
+
+          topic_root_reply = message["is_topic_message"] &&
+            reply["message_id"].to_s == message["message_thread_id"].to_s
+          !topic_root_reply
+        end
+
+        def build_reply_to(reply, chat_id)
+          return unless reply
+
+          user = extract_user(reply)
+          ChatSDK::Message.new(
+            id: reply["message_id"]&.to_s,
+            text: reply["text"] || reply["caption"] || "",
+            author: ChatSDK::Author.new(
+              id: user[:id],
+              name: user[:name],
+              platform: :telegram,
+              bot: !!reply.dig("from", "is_bot"),
+              locale: user[:locale]
+            ),
+            thread_id: resolve_thread_id(reply),
+            channel_id: chat_id,
+            platform: :telegram,
+            raw: reply
+          )
         end
 
         def parse_bot_command(message, user, chat_id, thread_id)

data/lib/chat_sdk/telegram/format_converter.rb

@@ -33,8 +33,156 @@ module ChatSDK
         parts.map.with_index { |part, i| i.odd? ? part : escape_special_chars(part) }.join
       end
 
+      def truncate_markdown_v2(text, limit)
+        text = text.to_s
+        return text if text.length <= limit
+
+        ellipsis = "\\.\\.\\."
+        slice = text[0, limit - ellipsis.length]
+        "#{trim_to_safe_boundary(slice)}#{ellipsis}"
+      end
+
       private
 
+      def trim_to_safe_boundary(text)
+        text = text[0...-1] while trailing_backslashes(text).odd?
+        link_detection_text, = mask_code_spans(text)
+        link_start = incomplete_link_start(link_detection_text)
+        text = text[0...link_start] if link_start
+
+        masked_links = mask_links(text)
+        masked, incomplete_code_start = mask_code_spans(masked_links)
+        text = text[0...incomplete_code_start] if incomplete_code_start
+        return text unless incomplete_code_start.nil?
+
+        marker_positions = Hash.new { |hash, key| hash[key] = [] }
+        chars = masked.chars
+        index = 0
+        while index < chars.length
+          if chars[index] == "\\"
+            index += 2
+            next
+          end
+          if %w[* _ ~ |].include?(chars[index])
+            run_length = 1
+            run_length += 1 while chars[index + run_length] == chars[index]
+            marker_positions[[chars[index], run_length]] << index
+            index += run_length
+          else
+            index += 1
+          end
+        end
+
+        cut = marker_positions.values
+          .select { |positions| positions.length.odd? }
+          .map(&:last)
+          .min
+        cut ? text[0...cut] : text
+      end
+
+      def trailing_backslashes(text)
+        text[/\\+\z/].to_s.length
+      end
+
+      def incomplete_link_start(text)
+        chars = text.chars
+        openings = []
+        index = 0
+        while index < chars.length
+          if chars[index] == "\\"
+            index += 2
+            next
+          elsif chars[index] == "["
+            openings << index
+          elsif chars[index] == "]" && !openings.empty?
+            opening = openings.pop
+            if chars[index + 1] == "("
+              closing = index + 2
+              closing += 1 while closing < chars.length &&
+                  (chars[closing] != ")" || escaped_at?(chars, closing))
+              return opening if closing == chars.length
+            end
+          end
+          index += 1
+        end
+        openings.last
+      end
+
+      def mask_code_spans(text)
+        chars = text.chars
+        masked = chars.dup
+        index = 0
+        while index < chars.length
+          if chars[index] == "\\"
+            index += 2
+            next
+          end
+          unless chars[index] == "`"
+            index += 1
+            next
+          end
+
+          run_length = 1
+          run_length += 1 while chars[index + run_length] == "`"
+          closing = index + run_length
+          while closing < chars.length
+            if chars[closing] == "`"
+              candidate_run_length = backtick_run_length(chars, closing)
+              break if candidate_run_length == run_length
+
+              closing += candidate_run_length
+            else
+              closing += 1
+            end
+          end
+          return [masked.join, index] if closing >= chars.length
+
+          closing_end = closing + run_length
+          (index...closing_end).each { |position| masked[position] = " " }
+          index = closing_end
+        end
+        [masked.join, nil]
+      end
+
+      def mask_links(text)
+        chars = text.chars
+        masked = chars.dup
+        openings = []
+        index = 0
+        while index < chars.length
+          if chars[index] == "\\"
+            index += 2
+            next
+          elsif chars[index] == "["
+            openings << index
+          elsif chars[index] == "]" && !openings.empty? && chars[index + 1] == "("
+            opening = openings.pop
+            closing = index + 2
+            closing += 1 while closing < chars.length &&
+                (chars[closing] != ")" || escaped_at?(chars, closing))
+            if closing < chars.length
+              (opening..closing).each { |position| masked[position] = " " }
+              index = closing
+            end
+          end
+          index += 1
+        end
+        masked.join
+      end
+
+      def backtick_run_length(chars, index)
+        length = 1
+        length += 1 while chars[index + length] == "`"
+        length
+      end
+
+      def escaped_at?(chars, index)
+        backslashes = 0
+        backslashes += 1 while index - backslashes - 1 >= 0 &&
+            chars[index - backslashes - 1] == "\\"
+        backslashes.odd?
+      end
+
       # Escape Telegram MarkdownV2 special chars outside of markdown syntax.
       # Preserves bold (**), italic (*), strikethrough (~~), links, etc.
       def escape_special_chars(text)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: chat_sdk-telegram
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 1.2.0
 platform: ruby
 authors:
 - Quentin Rousseau
@@ -15,14 +15,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0.1'
+        version: '1.2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0.1'
+        version: '1.2'
 - !ruby/object:Gem::Dependency
   name: faraday
   requirement: !ruby/object:Gem::Requirement