chat_sdk-messenger 0.2.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: ddb5167e642f3d5d79effdd65467cbfd7f1c4afae486a95204bf64708ff3019b
+  data.tar.gz: aa0f9eae474adae2691643fe4783ddff7c25894f2418036df6651642c6afc882
+SHA512:
+  metadata.gz: 8fb24bc5b9428c7d1575bd669a397215a465a78cf5f1ba98b13e1f500a04b89eeeed3471326584d612fa109e1417c227ad90e3f118c28596896f50aa12a83f60
+  data.tar.gz: f20ddad5394606ea1685b4ba9a70de96db0094d362dde49674a9a2a8f920802cf5d7631017cb952efeced188e72eb6118c1a6c9f2b01e4b877874530e605707f

data/lib/chat_sdk/messenger/adapter.rb

@@ -0,0 +1,147 @@
+# frozen_string_literal: true
+
+require "openssl"
+require "rack/utils"
+
+module ChatSDK
+  module Messenger
+    class Adapter < ChatSDK::Adapter::Base
+      capabilities :typing_indicator, :direct_messages, :file_uploads
+
+      attr_reader :client
+
+      def initialize(app_secret: nil, page_access_token: nil, verify_token: nil)
+        @app_secret = app_secret || ENV["FACEBOOK_APP_SECRET"]
+        @page_access_token = page_access_token || ENV["FACEBOOK_PAGE_ACCESS_TOKEN"]
+        @verify_token = verify_token || ENV["FACEBOOK_VERIFY_TOKEN"]
+
+        raise ChatSDK::ConfigurationError, "Messenger app_secret required" unless @app_secret
+        raise ChatSDK::ConfigurationError, "Messenger page_access_token required" unless @page_access_token
+
+        @client = ApiClient.new(@page_access_token)
+        @renderer = TemplateRenderer.new
+      end
+
+      def name
+        :messenger
+      end
+
+      # Inbound
+      def verify_request!(rack_request)
+        signature = rack_request.get_header("HTTP_X_HUB_SIGNATURE_256")
+
+        unless signature
+          raise ChatSDK::SignatureVerificationError, "Missing Facebook signature header"
+        end
+
+        body = rack_request.body.read
+        rack_request.body.rewind
+
+        expected = "sha256=#{OpenSSL::HMAC.hexdigest("SHA256", @app_secret, body)}"
+
+        unless Rack::Utils.secure_compare(signature, expected)
+          raise ChatSDK::SignatureVerificationError, "Invalid Facebook signature"
+        end
+
+        true
+      end
+
+      def ack_response(rack_request)
+        return nil unless rack_request.get?
+
+        params = rack_request.params
+        mode = params["hub.mode"]
+        token = params["hub.verify_token"]
+        challenge = params["hub.challenge"]
+
+        if mode == "subscribe" && token == @verify_token
+          [200, {}, [challenge.to_s]]
+        end
+      end
+
+      def parse_events(rack_request)
+        body = rack_request.body.read
+        rack_request.body.rewind
+
+        payload = JSON.parse(body)
+        EventParser.parse(payload)
+      rescue JSON::ParserError
+        []
+      end
+
+      # Outbound
+      def post_message(channel_id:, message:, thread_id: nil) # rubocop:disable Lint/UnusedMethodArgument
+        payload = prepare_message_payload(message)
+
+        result = @client.send_message(
+          recipient_id: channel_id,
+          message: payload
+        )
+
+        parse_messenger_message(result, channel_id)
+      end
+
+      def upload_file(channel_id:, io:, filename:, thread_id: nil, comment: nil) # rubocop:disable Lint/UnusedMethodArgument
+        raise ChatSDK::PlatformError.new(
+          "Messenger file uploads require a publicly accessible URL. Binary upload is not supported. " \
+          "Host the file at a public URL and send it as an attachment.",
+          adapter_name: :messenger
+        )
+      end
+
+      def open_dm(user_id)
+        user_id
+      end
+
+      def start_typing(channel_id:, thread_id: nil) # rubocop:disable Lint/UnusedMethodArgument
+        @client.send_action(recipient_id: channel_id, action: "typing_on")
+      end
+
+      def mention(user_id)
+        user_id
+      end
+
+      def render(postable_message)
+        if postable_message.card?
+          @renderer.render(postable_message.card)
+        else
+          postable_message.text
+        end
+      end
+
+      private
+
+      def prepare_message_payload(message)
+        msg = ChatSDK::PostableMessage.from(message)
+
+        if msg.card?
+          rendered = @renderer.render(msg.card)
+          if rendered.is_a?(Hash) && rendered[:attachment]
+            rendered
+          else
+            {"text" => rendered[:text] || msg.text || msg.card.fallback_text || ""}
+          end
+        else
+          {"text" => msg.text || ""}
+        end
+      end
+
+      def parse_messenger_message(data, channel_id)
+        ChatSDK::Message.new(
+          id: data["message_id"],
+          text: "",
+          author: ChatSDK::Author.new(
+            id: "bot",
+            name: "bot",
+            platform: :messenger,
+            bot: true
+          ),
+          thread_id: "messenger:#{data.dig("recipient_id") || channel_id}",
+          channel_id: channel_id,
+          platform: :messenger,
+          raw: data
+        )
+      end
+    end
+  end
+end

data/lib/chat_sdk/messenger/api_client.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module ChatSDK
+  module Messenger
+    class ApiClient
+      BASE_URL = "https://graph.facebook.com/v21.0/"
+
+      def initialize(page_access_token)
+        @page_access_token = page_access_token
+      end
+
+      def send_message(recipient_id:, message:)
+        body = {
+          "recipient" => {"id" => recipient_id},
+          "message" => message
+        }
+        request(:post, "me/messages", body)
+      end
+
+      def send_action(recipient_id:, action:)
+        body = {
+          "recipient" => {"id" => recipient_id},
+          "sender_action" => action
+        }
+        request(:post, "me/messages", body)
+      end
+
+      private
+
+      def connection
+        @connection ||= Faraday.new(url: BASE_URL) do |f|
+          f.request :json
+          f.response :json
+          f.adapter :net_http
+          f.params["access_token"] = @page_access_token
+        end
+      end
+
+      def request(method, path, body = nil)
+        response = connection.public_send(method, path) do |req|
+          req.body = body if body && method != :get
+        end
+
+        handle_response(response)
+      end
+
+      def handle_response(response)
+        body = response.body
+
+        if response.success?
+          return body if body.is_a?(Hash)
+
+          return {}
+        end
+
+        if response.status == 429
+          raise ChatSDK::RateLimitedError.new(
+            "Messenger API rate limited",
+            retry_after: nil,
+            status: response.status,
+            body: body,
+            adapter_name: :messenger
+          )
+        end
+
+        error_message = body.is_a?(Hash) ? body.dig("error", "message") : response.status
+        raise ChatSDK::PlatformError.new(
+          "Messenger API error: #{error_message}",
+          status: response.status,
+          body: body,
+          adapter_name: :messenger
+        )
+      end
+    end
+  end
+end

data/lib/chat_sdk/messenger/event_parser.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+module ChatSDK
+  module Messenger
+    class EventParser
+      class << self
+        def parse(payload)
+          return [] unless payload.is_a?(Hash)
+          return [] unless payload["object"] == "page"
+
+          events = []
+
+          (payload["entry"] || []).each do |entry|
+            (entry["messaging"] || []).each do |messaging|
+              event = parse_messaging(messaging)
+              events << event if event
+            end
+          end
+
+          events
+        end
+
+        private
+
+        def parse_messaging(messaging)
+          sender_id = messaging.dig("sender", "id")&.to_s
+          return nil unless sender_id
+
+          channel_id = sender_id
+          thread_id = "messenger:#{sender_id}"
+
+          if messaging["postback"]
+            parse_postback(messaging, sender_id, channel_id, thread_id)
+          elsif messaging["message"]
+            parse_message(messaging, sender_id, channel_id, thread_id)
+          end
+        end
+
+        def parse_message(messaging, sender_id, channel_id, thread_id)
+          message_data = messaging["message"]
+          text = message_data["text"] || ""
+
+          attachments = extract_attachments(message_data["attachments"])
+
+          if !attachments.empty?
+            text = [text, *attachments.map { |a| a[:url] }].reject(&:empty?).join("\n")
+          end
+
+          msg = ChatSDK::Message.new(
+            id: message_data["mid"],
+            text: text,
+            author: ChatSDK::Author.new(id: sender_id, name: sender_id, platform: :messenger, bot: false),
+            thread_id: thread_id,
+            channel_id: channel_id,
+            platform: :messenger,
+            raw: messaging
+          )
+
+          ChatSDK::Events::DirectMessage.new(
+            message: msg,
+            thread_id: thread_id,
+            channel_id: channel_id,
+            platform: :messenger,
+            adapter_name: :messenger,
+            raw: messaging
+          )
+        end
+
+        def parse_postback(messaging, sender_id, channel_id, thread_id)
+          postback = messaging["postback"]
+          payload = postback["payload"] || ""
+
+          user = ChatSDK::Author.new(
+            id: sender_id,
+            name: sender_id,
+            platform: :messenger,
+            bot: false
+          )
+
+          ChatSDK::Events::Action.new(
+            action_id: payload,
+            value: payload,
+            user: user,
+            thread_id: thread_id,
+            channel_id: channel_id,
+            platform: :messenger,
+            adapter_name: :messenger,
+            raw: messaging
+          )
+        end
+
+        def extract_attachments(attachments)
+          return [] unless attachments.is_a?(Array)
+
+          attachments.filter_map do |attachment|
+            url = attachment.dig("payload", "url")
+            next unless url
+
+            {type: attachment["type"], url: url}
+          end
+        end
+      end
+    end
+  end
+end

data/lib/chat_sdk/messenger/template_renderer.rb

@@ -0,0 +1,152 @@
+# frozen_string_literal: true
+
+module ChatSDK
+  module Messenger
+    class TemplateRenderer
+      def render(node)
+        case node.type
+        when :card then render_card(node)
+        else render_single(node)
+        end
+      end
+
+      private
+
+      def render_card(node)
+        buttons = collect_buttons(node)
+        title = node.attributes[:title]
+        subtitle = node.attributes[:subtitle]
+        image_url = find_image_url(node)
+        text_parts = collect_text_parts(node)
+        body_text = text_parts.join("\n")
+
+        if title && buttons.any?
+          # Generic Template: has title and buttons
+          element = {"title" => truncate(title, 80)}
+          element["subtitle"] = truncate(subtitle || body_text, 80) if subtitle || body_text.length.positive?
+          element["image_url"] = image_url if image_url
+          element["buttons"] = buttons.first(3)
+
+          {
+            attachment: {
+              "type" => "template",
+              "payload" => {
+                "template_type" => "generic",
+                "elements" => [element]
+              }
+            }
+          }
+        elsif buttons.any? && buttons.length <= 3 && !image_url
+          # Button Template: text + buttons, no image
+          fallback_text = [title, subtitle, body_text].compact.reject(&:empty?).join(" - ")
+          fallback_text = "Choose an option" if fallback_text.empty?
+
+          {
+            attachment: {
+              "type" => "template",
+              "payload" => {
+                "template_type" => "button",
+                "text" => truncate(fallback_text, 640),
+                "buttons" => buttons.first(3)
+              }
+            }
+          }
+        else
+          # Fallback: plain text
+          fallback = [title, subtitle, body_text].compact.reject(&:empty?).join("\n")
+          if buttons.any?
+            button_text = buttons.map { |b| b["title"] }.join(", ")
+            fallback = "#{fallback}\n[#{button_text}]" unless button_text.empty?
+          end
+          {text: fallback}
+        end
+      end
+
+      def collect_buttons(node)
+        buttons = []
+        node.children.each do |child|
+          case child.type
+          when :button
+            buttons << render_postback_button(child)
+          when :link_button
+            buttons << render_url_button(child)
+          when :actions
+            child.children.each do |action_child|
+              case action_child.type
+              when :button
+                buttons << render_postback_button(action_child)
+              when :link_button
+                buttons << render_url_button(action_child)
+              end
+            end
+          when :section
+            buttons.concat(collect_buttons(child))
+          end
+        end
+        buttons
+      end
+
+      def collect_text_parts(node)
+        parts = []
+        node.children.each do |child|
+          case child.type
+          when :text
+            parts << child.attributes[:content]
+          when :divider
+            parts << "---"
+          when :fields
+            child.children.each do |field|
+              parts << "#{field.attributes[:label]}: #{field.attributes[:value]}"
+            end
+          when :section
+            parts << child.attributes[:title] if child.attributes[:title]
+            parts.concat(collect_text_parts(child))
+          end
+        end
+        parts
+      end
+
+      def find_image_url(node)
+        node.children.each do |child|
+          return child.attributes[:url] if child.type == :image
+          if child.type == :section
+            url = find_image_url(child)
+            return url if url
+          end
+        end
+        nil
+      end
+
+      def render_postback_button(node)
+        {
+          "type" => "postback",
+          "title" => truncate(node.attributes[:text], 20),
+          "payload" => node.attributes[:id] || "button"
+        }
+      end
+
+      def render_url_button(node)
+        {
+          "type" => "web_url",
+          "title" => truncate(node.attributes[:text], 20),
+          "url" => node.attributes[:url]
+        }
+      end
+
+      def render_single(node)
+        case node.type
+        when :text
+          {text: node.attributes[:content]}
+        else
+          {text: node.fallback_text}
+        end
+      end
+
+      def truncate(text, max)
+        return "" unless text
+
+        (text.length > max) ? "#{text[0..max - 4]}..." : text
+      end
+    end
+  end
+end

data/lib/chat_sdk/messenger.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require "chat_sdk"
+require "faraday"
+require "faraday/net_http"
+require "zeitwerk"
+
+module ChatSDK
+  module Messenger
+    class << self
+      def loader
+        @loader ||= begin
+          loader = Zeitwerk::Loader.new
+          loader.tag = "chat_sdk-messenger"
+          loader.inflector.inflect("chat_sdk" => "ChatSDK")
+          loader.push_dir("#{__dir__}/messenger", namespace: ChatSDK::Messenger)
+          loader.setup
+          loader
+        end
+      end
+    end
+  end
+end
+
+ChatSDK::Messenger.loader

metadata

@@ -0,0 +1,75 @@
+--- !ruby/object:Gem::Specification
+name: chat_sdk-messenger
+version: !ruby/object:Gem::Version
+  version: 0.2.1
+platform: ruby
+authors:
+- Quentin Rousseau
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: chat_sdk
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+- !ruby/object:Gem::Dependency
+  name: faraday
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+description: Facebook Messenger adapter for the ChatSDK framework with HMAC-SHA256
+  verification and template rendering
+email:
+- quentin@rootly.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/chat_sdk/messenger.rb
+- lib/chat_sdk/messenger/adapter.rb
+- lib/chat_sdk/messenger/api_client.rb
+- lib/chat_sdk/messenger/event_parser.rb
+- lib/chat_sdk/messenger/template_renderer.rb
+homepage: https://github.com/rootlyhq/chat-sdk
+licenses:
+- MIT
+metadata:
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.2.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.16
+specification_version: 4
+summary: Facebook Messenger adapter for ChatSDK
+test_files: []