telegram-support-bot 0.1.06 → 0.1.07

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 443be16da398a9055e09a98aa7a828d887baa3828916f0afa2a509e9e228d1a3
-  data.tar.gz: 959d8dbe4eaeb3660bd688dafa26712575af0b0269d94acbea1e294ce9901af9
+  metadata.gz: e0dba7130ca446bc645510735687aa8501f31a6671cfb63fc29e7eb5e535c957
+  data.tar.gz: 3fa484d6c00969af671bdce6e964fd1484fce7ff96496aac9e92c3cd7e694dba
 SHA512:
-  metadata.gz: adfa333fb11bd3f68551a68a7b25f17d09a3840c5326ae65a0872741c326c7956e9d7ccdfe74f33d2e7f017f8e307f9fccd804a744df81004a05a6b460da0f7a
-  data.tar.gz: 75a42d5e219572496a5d3011a1c66373878a1cba685fbf7ff8574e9a00b451002df6b082f998e6d6be77c7b3dd8972d9d9e7faaaa3c486c83feece51724c8294
+  metadata.gz: c23fe383ec0166b10ab54edf9b536a83bc8973afbd9d373f04e9d281def477682406fd7b665f31c52b622b6e52ab33e47a7478c2193bc28e0a1a9139b06da840
+  data.tar.gz: ede12ddc03a8cb4cf213507d5fa8e35faeed2bb78d5c9dc76dfa1978901164130842f055b8b66fa604b2e9d3cf3a43881752ece10a94dd2063f09a92ebce19cd

data/.idea/workspace.xml

@@ -6,9 +6,7 @@
   <component name="ChangeListManager">
     <list default="true" id="edf498b0-8552-42f1-846d-0c79d29ff991" name="Changes" comment="">
       <change beforePath="$PROJECT_DIR$/.idea/workspace.xml" beforeDir="false" afterPath="$PROJECT_DIR$/.idea/workspace.xml" afterDir="false" />
-      <change beforePath="$PROJECT_DIR$/Gemfile" beforeDir="false" afterPath="$PROJECT_DIR$/Gemfile" afterDir="false" />
-      <change beforePath="$PROJECT_DIR$/lib/telegram_support_bot/adapters/telegram_bot_adapter.rb" beforeDir="false" afterPath="$PROJECT_DIR$/lib/telegram_support_bot/adapters/telegram_bot_adapter.rb" afterDir="false" />
-      <change beforePath="$PROJECT_DIR$/spec/telegram_support_bot/adapters/telegram_bot_adapter_spec.rb" beforeDir="false" afterPath="$PROJECT_DIR$/spec/telegram_support_bot/adapters/telegram_bot_adapter_spec.rb" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/README.md" beforeDir="false" afterPath="$PROJECT_DIR$/README.md" afterDir="false" />
     </list>
     <option name="SHOW_DIALOG" value="false" />
     <option name="HIGHLIGHT_CONFLICTS" value="true" />
@@ -39,30 +37,30 @@
     <option name="hideEmptyMiddlePackages" value="true" />
     <option name="showLibraryContents" value="true" />
   </component>
-  <component name="PropertiesComponent"><![CDATA[{
-  "keyToString": {
-    "DefaultRubyCreateTestTemplate": "Minitest Spec",
-    "RSpec.Unnamed.executor": "Run",
-    "Ruby.scratch_61.executor": "Run",
-    "RunOnceActivity.OpenProjectViewOnStart": "true",
-    "RunOnceActivity.ShowReadmeOnStart": "true",
-    "git-widget-placeholder": "main",
-    "last_opened_file_path": "/home/max/code/gems/telegram_support_bot",
-    "node.js.detected.package.eslint": "true",
-    "node.js.detected.package.tslint": "true",
-    "node.js.selected.package.eslint": "(autodetect)",
-    "node.js.selected.package.tslint": "(autodetect)",
-    "nodejs_package_manager_path": "npm",
-    "ruby.structure.view.model.defaults.configured": "true",
-    "settings.editor.selected.configurable": "org.jetbrains.plugins.ruby.settings.RubyActiveModuleSdkConfigurable",
-    "vue.rearranger.settings.migration": "true"
+  <component name="PropertiesComponent">{
+  &quot;keyToString&quot;: {
+    &quot;DefaultRubyCreateTestTemplate&quot;: &quot;Minitest Spec&quot;,
+    &quot;RSpec.Unnamed.executor&quot;: &quot;Run&quot;,
+    &quot;Ruby.scratch_61.executor&quot;: &quot;Run&quot;,
+    &quot;RunOnceActivity.OpenProjectViewOnStart&quot;: &quot;true&quot;,
+    &quot;RunOnceActivity.ShowReadmeOnStart&quot;: &quot;true&quot;,
+    &quot;git-widget-placeholder&quot;: &quot;main&quot;,
+    &quot;last_opened_file_path&quot;: &quot;/home/max/code/tg-sample&quot;,
+    &quot;node.js.detected.package.eslint&quot;: &quot;true&quot;,
+    &quot;node.js.detected.package.tslint&quot;: &quot;true&quot;,
+    &quot;node.js.selected.package.eslint&quot;: &quot;(autodetect)&quot;,
+    &quot;node.js.selected.package.tslint&quot;: &quot;(autodetect)&quot;,
+    &quot;nodejs_package_manager_path&quot;: &quot;npm&quot;,
+    &quot;ruby.structure.view.model.defaults.configured&quot;: &quot;true&quot;,
+    &quot;settings.editor.selected.configurable&quot;: &quot;org.jetbrains.plugins.ruby.settings.RubyActiveModuleSdkConfigurable&quot;,
+    &quot;vue.rearranger.settings.migration&quot;: &quot;true&quot;
   },
-  "keyToStringList": {
-    "com.intellij.ide.scratch.ScratchImplUtil$2/New Scratch File": [
-      "ruby"
+  &quot;keyToStringList&quot;: {
+    &quot;com.intellij.ide.scratch.ScratchImplUtil$2/New Scratch File&quot;: [
+      &quot;ruby&quot;
     ]
   }
-}]]></component>
+}</component>
   <component name="RecentsManager">
     <key name="CopyFile.RECENT_KEYS">
       <recent name="$PROJECT_DIR$/spec/telegram_support_bot/adapters" />
@@ -139,6 +137,10 @@
       <updated>1708600824931</updated>
       <workItem from="1708600827139" duration="10157000" />
       <workItem from="1708784534887" duration="682000" />
+      <workItem from="1708944130416" duration="99000" />
+      <workItem from="1708944249622" duration="627000" />
+      <workItem from="1708949675518" duration="80000" />
+      <workItem from="1708951183744" duration="310000" />
     </task>
     <servers />
   </component>

data/CHANGELOG.md

@@ -0,0 +1,21 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+## [0.1.07] - 2026-02-13
+
+### Added
+- Mirroring of `message_reaction` updates between support chat and user chats.
+- Message mapping storage (`message_map` and `reverse_message_map`) to correlate forwarded/replied messages for reaction sync.
+- Adapter API method `set_message_reaction` with implementations for both supported adapters.
+- Test coverage for reaction handling and adapter reaction calls.
+- Local polling helper script for development testing without Rails (`script/dev_poll.rb`).
+- README documentation for local development testing workflow.
+
+### Fixed
+- Local polling script now uses the proper polling call for `telegram-bot` gem (`get_updates`) and supports multiple client styles.
+- Reaction mapping now correctly handles wrapped Telegram API responses (`{ "ok": true, "result": ... }`).
+- Reaction mirroring now gracefully handles `REACTIONS_TOO_MANY` by retrying with a single reaction instead of crashing.
+- Reaction mapping lookup now tolerates chat/message ID type mismatches (string vs integer).
+- Added optional reaction-flow debug logs via `TSB_DEBUG=1`.
+- Support-chat reaction mirroring now also handles `message_reaction_count` updates (anonymous reaction counts).

data/README.md

@@ -115,13 +115,84 @@ end
 Implement custom adapters by inheriting from `TelegramSupportBot::Adapter::Base` and defining
 message sending and forwarding methods.
 
+## Handling User Privacy Settings for Message Forwarding
+
+Due to Telegram's privacy settings, users may have restricted the ability for bots to forward their
+messages with identifiable information. This restriction impacts the `forward_from` key, necessary
+for the bot to recognize and reply to users directly. To ensure seamless communication and support,
+we recommend including instructions in your bot's welcome message, asking users to allow message
+forwarding from your bot. Here's an example of how you can phrase this request:
+
+```
+Please mind, that your privacy settings might prevent the bot from sending you the reply from the support team. Please consider adding this bot to your allow-list for forwarding. Here’s how you can do it:
+  
+1. Go to Settings in your Telegram app.
+2. Tap on 'Privacy and Security'.
+3. Scroll to 'Forwarded Messages'.
+4. Add this bot to the list of exceptions by selecting 'Always Allow' for it.
+
+This will allow the bot to send you back replies from the support team.
+
+```
+
+Including such instructions can help in reducing the friction in user support interactions and
+ensure that your support team can effectively communicate with users through the bot.
 
 ## Development
 
 - Run `bin/setup` to install dependencies.
 - Use `rake spec` for tests and `bin/console` for an interactive prompt.
 - To install locally, use `bundle exec rake install`.
-- For releases, update `version.rb`, and run `bundle exec rake release`.
+- For releases, update `lib/telegram_support_bot/version.rb` and `CHANGELOG.md`, then run `bundle exec rake release`.
+
+### Local Testing Without Rails (Polling)
+
+You can run the bot locally without a Rails app by using the included script:
+
+Prerequisites:
+- Add the bot as an **administrator** in the support chat if you want support-side reactions to be delivered as updates.
+- Bots can set only one reaction per message via Bot API, so only one mirrored reaction is applied when multiple are present.
+
+1. Export required environment variables:
+
+```bash
+export TELEGRAM_BOT_TOKEN=your_bot_token
+export SUPPORT_CHAT_ID=your_support_chat_id
+# optional; defaults to telegram_bot
+export TSB_ADAPTER=telegram_bot
+# optional; used by telegram_bot adapter
+export TELEGRAM_BOT_USERNAME=your_bot_username
+```
+
+2. Disable webhook mode for that bot token (polling and webhooks cannot be used together):
+
+```bash
+curl -s "https://api.telegram.org/bot$TELEGRAM_BOT_TOKEN/deleteWebhook" > /dev/null
+```
+
+3. Start the local poller:
+
+```bash
+bundle exec ruby script/dev_poll.rb
+```
+
+4. In Telegram, verify:
+- user message is forwarded to support chat
+- support reply is sent back to user
+- reactions are mirrored in both directions
+
+If you want to test with `telegram_bot_ruby` adapter, set `TSB_ADAPTER=telegram_bot_ruby` and add
+the `telegram-bot-ruby` gem in your environment.
+
+### Switch Back To Webhook Mode
+
+After polling tests, set your webhook again:
+
+```bash
+curl -X POST "https://api.telegram.org/bot$TELEGRAM_BOT_TOKEN/setWebhook" \
+  -H "Content-Type: application/json" \
+  -d '{"url":"https://YOUR_PUBLIC_HOST/telegram/webhook","allowed_updates":["message","message_reaction","message_reaction_count","my_chat_member"]}'
+```
 
 ## Contributing
 

data/lib/telegram_support_bot/adapter_factory.rb

@@ -8,15 +8,24 @@ module TelegramSupportBot
     }.freeze
 
     def self.build(adapter_specification, adapter_options = {})
+      adapter_options ||= {}
       case adapter_specification
       when Symbol
-        adapter_class = ADAPTERS[adapter_specification].constantize
-        adapter_class.new(adapter_options)
+        class_name = ADAPTERS[adapter_specification]
+        raise ArgumentError, "Unsupported adapter specification: #{adapter_specification}" unless class_name
+
+        adapter_class = constantize(class_name)
+        adapter_class.new(**adapter_options)
       when Class
-        adapter_specification.new(adapter_options)
+        adapter_specification.new(**adapter_options)
       else
         raise ArgumentError, "Unsupported adapter specification: #{adapter_specification}"
       end
     end
+
+    def self.constantize(class_name)
+      class_name.split('::').reject(&:empty?).inject(Object) { |namespace, constant| namespace.const_get(constant) }
+    end
+    private_class_method :constantize
   end
 end

data/lib/telegram_support_bot/adapters/base.rb

@@ -35,6 +35,10 @@ module TelegramSupportBot
         # forward messages to the support chat
       end
 
+      def set_message_reaction(chat_id:, message_id:, reaction:, **options)
+        # set reaction to a message
+      end
+
       def on_message(&block)
         # Implementation to register a block to be called on new messages
       end

data/lib/telegram_support_bot/adapters/telegram_bot.rb

@@ -50,6 +50,15 @@ module TelegramSupportBot
           message_id:   message_id
         )
       end
+
+      def set_message_reaction(chat_id:, message_id:, reaction:, **options)
+        @bot.set_message_reaction(
+          chat_id:    chat_id,
+          message_id: message_id,
+          reaction:   reaction,
+          **options
+        )
+      end
     end
   end
 end

data/lib/telegram_support_bot/adapters/telegram_bot_ruby.rb

@@ -43,6 +43,10 @@ module TelegramSupportBot
       def forward_message(from_chat_id:, chat_id:, message_id:)
         bot.api.forward_message(chat_id: chat_id, from_chat_id: from_chat_id, message_id: message_id)
       end
+
+      def set_message_reaction(chat_id:, message_id:, reaction:, **options)
+        bot.api.set_message_reaction(chat_id: chat_id, message_id: message_id, reaction: reaction, **options)
+      end
     end
   end
 end

data/lib/telegram_support_bot/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module TelegramSupportBot
-  VERSION = "0.1.06"
+  VERSION = "0.1.07"
 end

data/lib/telegram_support_bot.rb

@@ -25,6 +25,18 @@ module TelegramSupportBot
       @adapter ||= AdapterFactory.build(configuration.adapter, configuration.adapter_options)
     end
 
+    def message_map
+      @message_map ||= {}
+    end
+
+    def reverse_message_map
+      @reverse_message_map ||= {}
+    end
+
+    def reaction_count_state
+      @reaction_count_state ||= {}
+    end
+
     def scheduler
       @scheduler ||= AutoAwayScheduler.new(adapter, configuration)
     end
@@ -34,6 +46,10 @@ module TelegramSupportBot
       if update['message']
         # Process standard messages
         process_message(update['message'])
+      elsif update['message_reaction']
+        process_message_reaction(update['message_reaction'])
+      elsif update['message_reaction_count']
+        process_message_reaction_count(update['message_reaction_count'])
       elsif update['my_chat_member']
         # Handle the bot being added to or removed from a chat
         handle_my_chat_member_update(update['my_chat_member'])
@@ -121,7 +137,18 @@ module TelegramSupportBot
             reply_to_message_id: message_id
           )
         else
-          adapter.send_media(chat_id: original_user_id, type: type, media: media, **options)
+          result = adapter.send_media(chat_id: original_user_id, type: type, media: media, **options)
+          if result
+            user_message_id = extract_message_id(result)
+            if user_message_id
+              support_message_id = message['message_id']
+              store_message_mapping(
+                support_message_id: support_message_id,
+                user_chat_id:       original_user_id,
+                user_message_id:    user_message_id
+              )
+            end
+          end
           # scheduler.cancel_scheduled_task(message_id)
         end
       end
@@ -156,10 +183,21 @@ module TelegramSupportBot
 
     def forward_message_to_support_chat(message)
       message_id = message['message_id']
-      adapter.forward_message(
+      result = adapter.forward_message(
         from_chat_id: message_chat_id,
         message_id:   message_id,
         chat_id:      configuration.support_chat_id)
+
+      if result
+        support_message_id = extract_message_id(result)
+        if support_message_id
+          store_message_mapping(
+            support_message_id: support_message_id,
+            user_chat_id:       message_chat_id,
+            user_message_id:    message_id
+          )
+        end
+      end
       # scheduler.schedule_auto_away_message(message_id, message_chat_id)
     end
 
@@ -171,6 +209,200 @@ module TelegramSupportBot
       end
     end
 
+    def process_message_reaction(message_reaction)
+      chat_id = message_reaction['chat']['id']
+      message_id = message_reaction['message_id']
+      new_reaction = message_reaction['new_reaction']
+
+      if same_chat_id?(chat_id, configuration.support_chat_id)
+        # Reaction in support chat, forward to user
+        if (mapping = find_message_mapping(message_id))
+          debug_log("Support->user mapping hit: support_message_id=#{message_id.inspect} => user_chat_id=#{mapping[:chat_id].inspect}, user_message_id=#{mapping[:message_id].inspect}")
+          mirror_reaction(
+            chat_id:    mapping[:chat_id],
+            message_id: mapping[:message_id],
+            reaction:   new_reaction
+          )
+        else
+          debug_log("Missing support->user mapping for support_message_id=#{message_id.inspect}; known_mappings=#{message_map.size}")
+        end
+      else
+        # Reaction in user chat, forward to support chat
+        if (support_message_id = reverse_message_map[reverse_mapping_key(chat_id, message_id)])
+          debug_log("User->support mapping hit: key=#{reverse_mapping_key(chat_id, message_id)} => support_message_id=#{support_message_id.inspect}")
+          mirror_reaction(
+            chat_id:    configuration.support_chat_id,
+            message_id: support_message_id,
+            reaction:   new_reaction
+          )
+        else
+          debug_log("Missing user->support mapping for key=#{reverse_mapping_key(chat_id, message_id)}; known_reverse_mappings=#{reverse_message_map.size}")
+        end
+      end
+    end
+
+    def process_message_reaction_count(message_reaction_count)
+      chat_id = message_reaction_count.dig('chat', 'id')
+      message_id = message_reaction_count['message_id']
+
+      unless same_chat_id?(chat_id, configuration.support_chat_id)
+        debug_log("Ignoring message_reaction_count outside support chat: chat_id=#{chat_id.inspect}")
+        return
+      end
+
+      mapping = find_message_mapping(message_id)
+      unless mapping
+        debug_log("Missing support->user mapping for message_reaction_count support_message_id=#{message_id.inspect}; known_mappings=#{message_map.size}")
+        return
+      end
+
+      state_key = reverse_mapping_key(chat_id, message_id)
+      previous_counts = reaction_count_state[state_key] || {}
+      current_counts, reaction_types = extract_reaction_counts(message_reaction_count['reactions'])
+      reaction_to_mirror = infer_reaction_from_count_diff(
+        previous_counts: previous_counts,
+        current_counts:  current_counts,
+        reaction_types:   reaction_types
+      )
+      reaction_count_state[state_key] = current_counts
+
+      if reaction_to_mirror.nil?
+        debug_log("No actionable reaction diff in message_reaction_count for support_message_id=#{message_id.inspect}")
+        return
+      end
+
+      debug_log("Support->user inferred reaction from count update: support_message_id=#{message_id.inspect} payload=#{reaction_to_mirror.inspect}")
+      mirror_reaction(
+        chat_id:    mapping[:chat_id],
+        message_id: mapping[:message_id],
+        reaction:   reaction_to_mirror
+      )
+    end
+
+    def mirror_reaction(chat_id:, message_id:, reaction:)
+      normalized_reaction = normalize_reaction_payload(reaction)
+      debug_log("Mirroring reaction to chat_id=#{chat_id.inspect} message_id=#{message_id.inspect} payload=#{normalized_reaction.inspect}")
+      adapter.set_message_reaction(chat_id: chat_id, message_id: message_id, reaction: normalized_reaction)
+      debug_log("Reaction mirrored to chat_id=#{chat_id.inspect} message_id=#{message_id.inspect}")
+    rescue StandardError => error
+      if reaction_too_many_error?(error) && normalized_reaction.size > 1
+        begin
+          adapter.set_message_reaction(chat_id: chat_id, message_id: message_id, reaction: [normalized_reaction.first])
+          debug_log("Reaction mirrored after fallback to single reaction for chat_id=#{chat_id.inspect} message_id=#{message_id.inspect}")
+        rescue StandardError => retry_error
+          warn_reaction_forwarding_failure(chat_id: chat_id, message_id: message_id, error: retry_error)
+        end
+      else
+        warn_reaction_forwarding_failure(chat_id: chat_id, message_id: message_id, error: error)
+      end
+    end
+
+    def normalize_reaction_payload(reaction)
+      return [] if reaction.nil?
+      return reaction if reaction.is_a?(Array)
+
+      [reaction]
+    end
+
+    def reaction_too_many_error?(error)
+      error.message.to_s.upcase.include?('REACTIONS_TOO_MANY')
+    end
+
+    def warn_reaction_forwarding_failure(chat_id:, message_id:, error:)
+      warn "Failed to mirror reaction to chat_id=#{chat_id} message_id=#{message_id}: #{error.class}: #{error.message}"
+    end
+
+    def extract_reaction_counts(reactions)
+      counts = {}
+      reaction_types = {}
+
+      Array(reactions).each do |reaction|
+        reaction_type = reaction['type'] || reaction[:type]
+        next unless reaction_type
+
+        key = reaction_type_key(reaction_type)
+        next if key.nil?
+
+        counts[key] = (reaction['total_count'] || reaction[:total_count] || 0).to_i
+        reaction_types[key] = reaction_type
+      end
+
+      [counts, reaction_types]
+    end
+
+    def infer_reaction_from_count_diff(previous_counts:, current_counts:, reaction_types:)
+      increments = []
+      current_counts.each do |key, current_value|
+        previous_value = previous_counts.fetch(key, 0)
+        diff = current_value - previous_value
+        increments << [key, diff, current_value] if diff.positive?
+      end
+
+      if increments.any?
+        selected_key = increments.max_by { |(_, diff, current_value)| [diff, current_value] }[0]
+        return [reaction_types.fetch(selected_key)]
+      end
+
+      removed_all = previous_counts.values.any?(&:positive?) && current_counts.values.all?(&:zero?)
+      return [] if removed_all
+
+      nil
+    end
+
+    def reaction_type_key(reaction_type)
+      type = reaction_type['type'] || reaction_type[:type]
+
+      case type
+      when 'emoji', :emoji
+        "emoji:#{reaction_type['emoji'] || reaction_type[:emoji]}"
+      when 'custom_emoji', :custom_emoji
+        "custom_emoji:#{reaction_type['custom_emoji_id'] || reaction_type[:custom_emoji_id]}"
+      when 'paid', :paid
+        'paid'
+      else
+        nil
+      end
+    end
+
+    def store_message_mapping(support_message_id:, user_chat_id:, user_message_id:)
+      mapping = { chat_id: user_chat_id, message_id: user_message_id }
+      message_map[support_message_id] = mapping
+      message_map[support_message_id.to_s] = mapping
+      reverse_message_map[reverse_mapping_key(user_chat_id, user_message_id)] = support_message_id
+    end
+
+    def find_message_mapping(support_message_id)
+      message_map[support_message_id] ||
+        message_map[support_message_id.to_s] ||
+        message_map[support_message_id.to_i]
+    end
+
+    def reverse_mapping_key(chat_id, message_id)
+      "#{chat_id}:#{message_id}"
+    end
+
+    def same_chat_id?(left, right)
+      left == right || left.to_s == right.to_s
+    end
+
+    def debug_log(message)
+      return unless ENV['TSB_DEBUG'] == '1'
+
+      puts "[TelegramSupportBot DEBUG] #{message}"
+    end
+
+    def extract_message_id(result)
+      if result.is_a?(Hash)
+        return result['message_id'] || result[:message_id] ||
+               result.dig('result', 'message_id') || result.dig(:result, :message_id) ||
+               result.dig('result', :message_id) || result.dig(:result, 'message_id')
+      end
+
+      return result.message_id if result.respond_to?(:message_id)
+
+      nil
+    end
+
     def send_welcome_message(chat_id:)
       welcome_text = "Hello! Thank you for adding me to your chat. To configure your system, please use the following support chat ID: <code>#{chat_id}</code>."
       adapter.send_message(chat_id: chat_id, text: welcome_text, parse_mode: 'HTML')
@@ -183,4 +415,3 @@ module TelegramSupportBot
     @adapter = nil
   end
 end
-

data/script/dev_poll.rb

@@ -0,0 +1,102 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'telegram_support_bot'
+require 'telegram/bot'
+
+token = ENV.fetch('TELEGRAM_BOT_TOKEN')
+support_chat_id = Integer(ENV.fetch('SUPPORT_CHAT_ID'))
+adapter = ENV.fetch('TSB_ADAPTER', 'telegram_bot')
+username = ENV['TELEGRAM_BOT_USERNAME']
+
+adapter_options = { token: token }
+adapter_options[:username] = username if username && !username.empty?
+
+TelegramSupportBot.configure do |config|
+  config.adapter = adapter.to_sym
+  config.adapter_options = adapter_options
+  config.support_chat_id = support_chat_id
+  config.welcome_message = 'Hi! How can we help you?'
+end
+
+client = Telegram::Bot::Client.new(token)
+offset = 0
+
+puts "TelegramSupportBot dev poller started (adapter=#{adapter}, support_chat_id=#{support_chat_id})."
+puts 'Press Ctrl+C to stop.'
+
+def extract_result(payload)
+  return payload['result'] if payload.is_a?(Hash) && payload.key?('result')
+  return payload[:result] if payload.is_a?(Hash) && payload.key?(:result)
+
+  payload
+end
+
+def verify_reaction_update_prerequisites(client:, support_chat_id:)
+  me_response = client.get_me
+  me_result = extract_result(me_response)
+  bot_user_id = me_result['id'] || me_result[:id]
+  return puts('Warning: could not verify bot identity via getMe.') unless bot_user_id
+
+  member_response = client.get_chat_member(chat_id: support_chat_id, user_id: bot_user_id)
+  member_result = extract_result(member_response)
+  status = member_result['status'] || member_result[:status]
+
+  unless %w[administrator creator].include?(status)
+    puts "Warning: bot status in support chat is #{status.inspect}. message_reaction/message_reaction_count updates require bot admin rights."
+  end
+rescue StandardError => e
+  puts "Warning: failed to verify reaction prerequisites: #{e.class}: #{e.message}"
+end
+
+verify_reaction_update_prerequisites(client: client, support_chat_id: support_chat_id)
+
+def debug_update_summary(update)
+  return unless ENV['TSB_DEBUG'] == '1'
+
+  if update['message_reaction']
+    chat_id = update.dig('message_reaction', 'chat', 'id')
+    message_id = update.dig('message_reaction', 'message_id')
+    puts "[TSB POLL DEBUG] update=message_reaction chat_id=#{chat_id.inspect} message_id=#{message_id.inspect}"
+  elsif update['message_reaction_count']
+    chat_id = update.dig('message_reaction_count', 'chat', 'id')
+    message_id = update.dig('message_reaction_count', 'message_id')
+    puts "[TSB POLL DEBUG] update=message_reaction_count chat_id=#{chat_id.inspect} message_id=#{message_id.inspect}"
+  elsif update['message']
+    chat_id = update.dig('message', 'chat', 'id')
+    message_id = update.dig('message', 'message_id')
+    puts "[TSB POLL DEBUG] update=message chat_id=#{chat_id.inspect} message_id=#{message_id.inspect}"
+  elsif update['my_chat_member']
+    chat_id = update.dig('my_chat_member', 'chat', 'id')
+    puts "[TSB POLL DEBUG] update=my_chat_member chat_id=#{chat_id.inspect}"
+  else
+    puts "[TSB POLL DEBUG] update=other keys=#{update.keys.inspect}"
+  end
+end
+
+loop do
+  params = {
+    offset: offset,
+    timeout: 25,
+    allowed_updates: %w[message message_reaction message_reaction_count my_chat_member]
+  }
+  response =
+    if client.respond_to?(:get_updates)
+      client.get_updates(**params)
+    elsif client.respond_to?(:api) && client.api.respond_to?(:get_updates)
+      client.api.get_updates(**params)
+    elsif client.respond_to?(:api) && client.api.respond_to?(:getUpdates)
+      client.api.getUpdates(**params)
+    else
+      raise 'Unsupported Telegram client API for polling'
+    end
+  updates = response['result'] || response[:result] || []
+
+  updates.each do |update|
+    normalized = update.respond_to?(:to_h) ? update.to_h : update
+    debug_update_summary(normalized)
+    TelegramSupportBot.process_update(normalized)
+    update_id = normalized['update_id'] || normalized[:update_id]
+    offset = update_id + 1 if update_id
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: telegram-support-bot
 version: !ruby/object:Gem::Version
-  version: 0.1.06
+  version: 0.1.07
 platform: ruby
 authors:
 - Max Buslaev
-autorequire: 
+autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-02-26 00:00:00.000000000 Z
+date: 2026-02-13 00:00:00.000000000 Z
 dependencies: []
 description: |-
   The telegram_support_bot gem provides Rails applications with an
@@ -28,6 +28,7 @@ extra_rdoc_files: []
 files:
 - ".idea/workspace.xml"
 - ".rspec"
+- CHANGELOG.md
 - CODE_OF_CONDUCT.md
 - Gemfile
 - LICENSE.txt
@@ -41,13 +42,13 @@ files:
 - lib/telegram_support_bot/auto_away_scheduler.rb
 - lib/telegram_support_bot/configuration.rb
 - lib/telegram_support_bot/version.rb
+- script/dev_poll.rb
 - sig/telegram_support_bot.rbs
-- telegram_support_bot.gemspec
 homepage: https://github.com/austerlitz/telegram_support_bot
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -62,8 +63,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.3
-signing_key: 
+rubygems_version: 3.5.11
+signing_key:
 specification_version: 4
 summary: A Rails gem for integrating a Telegram bot into your application for seamless
   support desk functionality.

data/telegram_support_bot.gemspec

@@ -1,37 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'lib/telegram_support_bot/version'
-
-Gem::Specification.new do |spec|
-  spec.name = 'telegram-support-bot'
-  spec.version = TelegramSupportBot::VERSION
-  spec.authors = ['Max Buslaev']
-  spec.email = ['max@buslaev.net']
-
-  spec.summary = 'A Rails gem for integrating a Telegram bot into your application for seamless
-support desk functionality.'
-  spec.description = 'The telegram_support_bot gem provides Rails applications with an
-easy-to-integrate Telegram bot, designed to enhance customer support services.
-By leveraging this gem, developers can swiftly add a Telegram-based support desk to their
-application, enabling direct communication between users and support agents through Telegram.
-Features include automatic message forwarding to a designated secret chat for support agents,
-the ability to reply directly from the secret chat to users, and customizable responses
-for common queries. This gem simplifies the process of setting up a robust support channel on one of
-the most popular messaging platforms, making it an ideal solution for businesses looking to improve
-their customer service experience.'
-  spec.homepage = 'https://github.com/austerlitz/telegram_support_bot'
-  spec.license = 'MIT'
-  # spec.required_ruby_version = '>= 2.6.0'
-
-  # Specify which files should be added to the gem when it is released.
-  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
-  spec.files = Dir.chdir(__dir__) do
-    `git ls-files -z`.split("\x0").reject do |f|
-      (File.expand_path(f) == __FILE__) || f.start_with?(*%w[bin/ test/ spec/ features/ .git .circleci appveyor])
-    end
-  end
-  spec.bindir = 'exe'
-  spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
-  spec.require_paths = ['lib']
-
-end