chat_sdk-twilio 0.2.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 21bad3d99ab33873fc54e54fc57e33b3171cfa946fc39845962b1e174b347685
+  data.tar.gz: acc910c814fb03b916e684afcf16c56d29f479569a67e9a0691f7029400c6df5
+SHA512:
+  metadata.gz: 3f1ea62aed56dfcd1edc793ad86e59160dc6e045ac5cfae0d9b8938da22d49fb854573c912d927ccc5ee3d5d167c6639d80f901d3a5b98cc6aa54d852c731464
+  data.tar.gz: 7b15c533e2cb0807524d66b19ad9bcd7d17926e2571f9b8ead7cf810f4c720014733839fcaeab6dbeada15030ce674e0a1339b3219e3a81ce0bc76775bb55220

data/lib/chat_sdk/twilio/adapter.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+require "rack/utils"
+
+module ChatSDK
+  module Twilio
+    class Adapter < ChatSDK::Adapter::Base
+      capabilities :direct_messages, :file_uploads
+
+      attr_reader :client
+
+      def initialize(account_sid: nil, auth_token: nil, phone_number: nil, messaging_service_sid: nil, webhook_url: nil)
+        @account_sid = account_sid || ENV["TWILIO_ACCOUNT_SID"]
+        @auth_token = auth_token || ENV["TWILIO_AUTH_TOKEN"]
+        @phone_number = phone_number || ENV["TWILIO_PHONE_NUMBER"]
+        @messaging_service_sid = messaging_service_sid || ENV["TWILIO_MESSAGING_SERVICE_SID"]
+        @webhook_url = webhook_url
+
+        raise ChatSDK::ConfigurationError, "Twilio account_sid required" unless @account_sid
+        raise ChatSDK::ConfigurationError, "Twilio auth_token required" unless @auth_token
+        raise ChatSDK::ConfigurationError, "Twilio phone_number or messaging_service_sid required" unless @phone_number || @messaging_service_sid
+
+        @client = ApiClient.new(@account_sid, @auth_token)
+      end
+
+      def name
+        :twilio
+      end
+
+      # Inbound
+      def verify_request!(rack_request)
+        signature = rack_request.get_header("HTTP_X_TWILIO_SIGNATURE")
+
+        unless signature
+          raise ChatSDK::SignatureVerificationError, "Missing Twilio signature header"
+        end
+
+        body = rack_request.body.read
+        rack_request.body.rewind
+
+        params = Rack::Utils.parse_query(body)
+        url = @webhook_url || rack_request.url
+
+        Signature.verify!(@auth_token, url, params, signature)
+      end
+
+      def ack_response(_rack_request)
+        nil
+      end
+
+      def parse_events(rack_request)
+        body = rack_request.body.read
+        rack_request.body.rewind
+
+        params = Rack::Utils.parse_query(body)
+        EventParser.parse(params)
+      rescue ArgumentError
+        []
+      end
+
+      # Outbound
+      def post_message(channel_id:, message:, thread_id: nil) # rubocop:disable Lint/UnusedMethodArgument
+        text = prepare_message_payload(message)
+
+        result = @client.send_message(
+          to: channel_id,
+          body: text,
+          from: @phone_number,
+          messaging_service_sid: @messaging_service_sid
+        )
+
+        parse_twilio_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(
+          "Twilio MMS requires a publicly accessible MediaUrl. Binary upload is not supported. " \
+          "Host the file at a public URL and send it as a message with the URL included.",
+          adapter_name: :twilio
+        )
+      end
+
+      def open_dm(user_id)
+        user_id
+      end
+
+      def mention(user_id)
+        user_id
+      end
+
+      def render(postable_message)
+        if postable_message.card?
+          @text_renderer ||= Cards::Renderer.new
+          @text_renderer.render(postable_message.card)
+        else
+          postable_message.text
+        end
+      end
+
+      private
+
+      def prepare_message_payload(message)
+        msg = ChatSDK::PostableMessage.from(message)
+        msg.text || msg.card&.fallback_text || ""
+      end
+
+      def parse_twilio_message(data, channel_id)
+        ChatSDK::Message.new(
+          id: data["sid"],
+          text: data["body"] || "",
+          author: ChatSDK::Author.new(
+            id: data["from"] || "bot",
+            name: data["from"] || "bot",
+            platform: :twilio,
+            bot: true
+          ),
+          thread_id: data["sid"],
+          channel_id: channel_id,
+          platform: :twilio,
+          raw: data
+        )
+      end
+    end
+  end
+end

data/lib/chat_sdk/twilio/api_client.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module ChatSDK
+  module Twilio
+    class ApiClient
+      BASE_URL = "https://api.twilio.com"
+
+      def initialize(account_sid, auth_token)
+        @account_sid = account_sid
+        @auth_token = auth_token
+      end
+
+      def send_message(to:, body:, from: nil, messaging_service_sid: nil, media_url: nil)
+        params = {"To" => to, "Body" => body}
+        params["From"] = from if from
+        params["MessagingServiceSid"] = messaging_service_sid if messaging_service_sid
+        params["MediaUrl"] = media_url if media_url
+
+        response = connection.post(messages_path, URI.encode_www_form(params))
+        handle_response(response)
+      end
+
+      private
+
+      def messages_path
+        "/2010-04-01/Accounts/#{@account_sid}/Messages.json"
+      end
+
+      def connection
+        @connection ||= Faraday.new(url: BASE_URL) do |f|
+          f.request :authorization, :basic, @account_sid, @auth_token
+          f.headers["Content-Type"] = "application/x-www-form-urlencoded"
+          f.response :json
+          f.adapter :net_http
+        end
+      end
+
+      def handle_response(response)
+        body = response.body
+
+        return body if response.success?
+
+        if response.status == 429
+          raise ChatSDK::RateLimitedError.new(
+            "Twilio API rate limited",
+            retry_after: nil,
+            status: response.status,
+            body: body,
+            adapter_name: :twilio
+          )
+        end
+
+        message = body.is_a?(Hash) ? body["message"] : response.status
+        raise ChatSDK::PlatformError.new(
+          "Twilio API error: #{message}",
+          status: response.status,
+          body: body,
+          adapter_name: :twilio
+        )
+      end
+    end
+  end
+end

data/lib/chat_sdk/twilio/event_parser.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module ChatSDK
+  module Twilio
+    class EventParser
+      class << self
+        def parse(params)
+          return [] unless params.is_a?(Hash) && params["MessageSid"]
+
+          author = ChatSDK::Author.new(
+            id: params["From"] || "unknown",
+            name: params["From"] || "unknown",
+            platform: :twilio,
+            bot: false
+          )
+
+          attachments = extract_attachments(params)
+
+          text = params["Body"] || ""
+          text = "#{text}\n#{attachments.map { |a| a[:url] }.join("\n")}" if attachments.any? && !text.empty?
+          text = attachments.map { |a| a[:url] }.join("\n") if attachments.any? && (params["Body"].nil? || params["Body"].empty?)
+
+          msg = ChatSDK::Message.new(
+            id: params["MessageSid"],
+            text: text,
+            author: author,
+            thread_id: params["MessageSid"],
+            channel_id: params["To"] || "unknown",
+            platform: :twilio,
+            raw: params
+          )
+
+          [ChatSDK::Events::DirectMessage.new(
+            message: msg,
+            thread_id: params["MessageSid"],
+            channel_id: params["To"] || "unknown",
+            platform: :twilio,
+            adapter_name: :twilio,
+            raw: params
+          )]
+        end
+
+        private
+
+        def extract_attachments(params)
+          num_media = (params["NumMedia"] || "0").to_i
+          return [] if num_media.zero?
+
+          (0...num_media).map do |i|
+            {
+              url: params["MediaUrl#{i}"],
+              content_type: params["MediaContentType#{i}"]
+            }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/chat_sdk/twilio/signature.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require "openssl"
+require "base64"
+require "rack/utils"
+
+module ChatSDK
+  module Twilio
+    module Signature
+      def self.verify!(auth_token, url, params, signature)
+        data = url + params.sort.flatten.join
+        digest = OpenSSL::HMAC.digest("SHA1", auth_token, data)
+        expected = Base64.strict_encode64(digest)
+
+        unless Rack::Utils.secure_compare(expected, signature)
+          raise ChatSDK::SignatureVerificationError, "Invalid Twilio signature"
+        end
+
+        true
+      end
+    end
+  end
+end

data/lib/chat_sdk/twilio.rb

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

metadata

@@ -0,0 +1,75 @@
+--- !ruby/object:Gem::Specification
+name: chat_sdk-twilio
+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: Twilio SMS/MMS adapter for the ChatSDK framework with HMAC-SHA1 signature
+  verification
+email:
+- quentin@rootly.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/chat_sdk/twilio.rb
+- lib/chat_sdk/twilio/adapter.rb
+- lib/chat_sdk/twilio/api_client.rb
+- lib/chat_sdk/twilio/event_parser.rb
+- lib/chat_sdk/twilio/signature.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: Twilio SMS/MMS adapter for ChatSDK
+test_files: []