chat_sdk-x 0.3.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 5d20a70961f55e903fc2adc6155f5e3bbff60910df577afc4948421f611d08f0
+  data.tar.gz: 00c9a4d7394037ec77d1cdbd3fc6f9462009a61c01c8f15acc349fb872b63682
+SHA512:
+  metadata.gz: 3edc7cf5cc52d757d1096f248e35763e192cda98f904ec3dfde7c7fad5c0b17290efe57d853c5cb09f686b8b54f302011376189aefa0ed3177f08b275730a2d7
+  data.tar.gz: e3954e97efc0e99e52787e9934f26d4f0e36df7827352b2a960da04cbfe37346b6a6647c4e8bd5d11cd43692149f3fafe8ea2881b92cd4665cec6c676cefaabc

data/lib/chat_sdk/x/adapter.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+require "openssl"
+require "base64"
+require "rack/utils"
+
+module ChatSDK
+  module X
+    class Adapter < ChatSDK::Adapter::Base
+      capabilities :direct_messages, :reactions
+
+      attr_reader :client
+
+      def initialize(access_token: nil, consumer_secret: nil, user_id: nil)
+        @access_token = access_token || ENV["X_ACCESS_TOKEN"]
+        @consumer_secret = consumer_secret || ENV["X_CONSUMER_SECRET"]
+        @user_id = user_id || ENV["X_USER_ID"]
+
+        raise ChatSDK::ConfigurationError, "X access_token required" unless @access_token
+        raise ChatSDK::ConfigurationError, "X consumer_secret required" unless @consumer_secret
+
+        @client = ApiClient.new(@access_token)
+      end
+
+      def name
+        :x
+      end
+
+      # Inbound
+      def verify_request!(rack_request)
+        body = rack_request.body.read
+        rack_request.body.rewind
+
+        signature = rack_request.get_header("HTTP_X_TWITTER_WEBHOOKS_SIGNATURE")
+
+        unless signature
+          raise ChatSDK::SignatureVerificationError, "Missing X signature header"
+        end
+
+        expected = "sha256=#{Base64.strict_encode64(OpenSSL::HMAC.digest("SHA256", @consumer_secret, body))}"
+
+        unless Rack::Utils.secure_compare(signature, expected)
+          raise ChatSDK::SignatureVerificationError, "Invalid X signature"
+        end
+
+        true
+      end
+
+      def ack_response(rack_request)
+        return nil unless rack_request.get?
+
+        crc_token = rack_request.params["crc_token"]
+        return nil unless crc_token
+
+        response_token = "sha256=#{Base64.strict_encode64(OpenSSL::HMAC.digest("SHA256", @consumer_secret, crc_token))}"
+
+        [200, {"content-type" => "application/json"}, [JSON.generate({"response_token" => response_token})]]
+      end
+
+      def parse_events(rack_request)
+        payload = read_json_body(rack_request)
+        EventParser.parse(payload, bot_user_id: @user_id)
+      rescue JSON::ParserError
+        []
+      end
+
+      # Outbound
+      def post_message(channel_id:, message:, thread_id: nil)
+        msg = ChatSDK::PostableMessage.from(message)
+        text = msg.text || msg.card&.fallback_text || ""
+
+        if thread_id&.start_with?("x:dm:")
+          result = @client.send_dm(participant_id: channel_id, text: text)
+          message_id = result.dig("dm_event", "id") || result["id"]
+
+          ChatSDK::Message.new(
+            id: message_id,
+            text: text,
+            author: ChatSDK::Author.new(id: @user_id || "bot", name: "bot", platform: :x, bot: true),
+            thread_id: thread_id,
+            channel_id: channel_id,
+            platform: :x,
+            raw: result
+          )
+        else
+          payload = {text: text}
+          payload[:reply] = {in_reply_to_tweet_id: channel_id} if channel_id && thread_id
+          result = @client.create_tweet(**payload)
+          tweet_id = result.dig("data", "id") || result["id"]
+
+          ChatSDK::Message.new(
+            id: tweet_id,
+            text: text,
+            author: ChatSDK::Author.new(id: @user_id || "bot", name: "bot", platform: :x, bot: true),
+            thread_id: thread_id || "x:post:#{tweet_id}",
+            channel_id: channel_id,
+            platform: :x,
+            raw: result
+          )
+        end
+      end
+
+      def add_reaction(channel_id:, message_id:, emoji:) # rubocop:disable Lint/UnusedMethodArgument
+        @client.like_tweet(user_id: @user_id, tweet_id: message_id)
+      end
+
+      def remove_reaction(channel_id:, message_id:, emoji:) # rubocop:disable Lint/UnusedMethodArgument
+        @client.unlike_tweet(user_id: @user_id, tweet_id: message_id)
+      end
+
+      def open_dm(user_id)
+        user_id
+      end
+
+      def mention(user_id)
+        "@#{user_id}"
+      end
+
+      def render(postable_message)
+        postable_message.text
+      end
+    end
+  end
+end

data/lib/chat_sdk/x/api_client.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module ChatSDK
+  module X
+    class ApiClient < ChatSDK::ApiClient::Base
+      BASE_URL = "https://api.x.com"
+
+      def initialize(access_token)
+        @access_token = access_token
+      end
+
+      def create_tweet(text:, reply: nil)
+        body = {"text" => text}
+        body["reply"] = reply if reply
+        request(:post, "/2/tweets", body)
+      end
+
+      def send_dm(participant_id:, text:)
+        request(:post, "/2/dm_conversations/with/#{participant_id}/messages", {"text" => text})
+      end
+
+      def like_tweet(user_id:, tweet_id:)
+        request(:post, "/2/users/#{user_id}/likes", {"tweet_id" => tweet_id})
+      end
+
+      def unlike_tweet(user_id:, tweet_id:)
+        request(:delete, "/2/users/#{user_id}/likes/#{tweet_id}")
+      end
+
+      private
+
+      def base_url
+        BASE_URL
+      end
+
+      def adapter_name
+        :x
+      end
+
+      def configure_auth(faraday)
+        faraday.headers["Authorization"] = "Bearer #{@access_token}"
+      end
+
+      def extract_error_message(response)
+        body = response.body
+        return response.status.to_s unless body.is_a?(Hash)
+
+        body.dig("errors", 0, "message") || body["detail"] || response.status.to_s
+      end
+
+      def extract_retry_after(response)
+        reset = response.headers["x-rate-limit-reset"]
+        return nil unless reset
+
+        seconds = reset.to_i - Time.now.to_i
+        [seconds, 1].max
+      end
+    end
+  end
+end

data/lib/chat_sdk/x/event_parser.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module ChatSDK
+  module X
+    class EventParser
+      class << self
+        def parse(payload, bot_user_id: nil)
+          return [] unless payload.is_a?(Hash)
+
+          events = []
+          events.concat(parse_mentions(payload, bot_user_id))
+          events.concat(parse_direct_messages(payload, bot_user_id))
+          events
+        end
+
+        private
+
+        def parse_mentions(payload, bot_user_id)
+          tweet_events = payload["tweet_create_events"] || payload.dig("post", "mention", "create") || []
+          return [] unless tweet_events.is_a?(Array)
+
+          tweet_events.filter_map do |data|
+            data = data["data"] if data.key?("data")
+            author_id = data["author_id"] || data.dig("user", "id_str") || data.dig("user", "id")&.to_s
+            next if bot_user_id && author_id == bot_user_id
+
+            message_id = data["id"] || data["id_str"]
+            text = data["text"] || ""
+            conversation_id = data["conversation_id"] || message_id
+
+            msg = ChatSDK::Message.new(
+              id: message_id&.to_s,
+              text: text,
+              author: ChatSDK::Author.new(id: author_id || "unknown", name: author_id || "unknown", platform: :x, bot: false),
+              thread_id: "x:post:#{conversation_id}",
+              channel_id: author_id,
+              platform: :x,
+              raw: data
+            )
+
+            ChatSDK::Events::Mention.new(
+              message: msg,
+              thread_id: "x:post:#{conversation_id}",
+              channel_id: author_id,
+              platform: :x,
+              adapter_name: :x,
+              raw: data
+            )
+          end
+        end
+
+        def parse_direct_messages(payload, bot_user_id)
+          dm_events = payload["direct_message_events"] || payload.dig("dm", "received") || []
+          return [] unless dm_events.is_a?(Array)
+
+          dm_events.filter_map do |data|
+            data = data["data"] if data.is_a?(Hash) && data.key?("data")
+            sender_id = data["sender_id"] || data.dig("message_create", "sender_id")
+            next if bot_user_id && sender_id == bot_user_id
+
+            text = data["text"] || data.dig("message_create", "message_data", "text") || ""
+            message_id = data["id"] || data["id_str"]
+
+            msg = ChatSDK::Message.new(
+              id: message_id&.to_s,
+              text: text,
+              author: ChatSDK::Author.new(id: sender_id || "unknown", name: sender_id || "unknown", platform: :x, bot: false),
+              thread_id: "x:dm:#{sender_id}",
+              channel_id: sender_id,
+              platform: :x,
+              raw: data
+            )
+
+            ChatSDK::Events::DirectMessage.new(
+              message: msg,
+              thread_id: "x:dm:#{sender_id}",
+              channel_id: sender_id,
+              platform: :x,
+              adapter_name: :x,
+              raw: data
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/chat_sdk/x.rb

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

metadata

@@ -0,0 +1,73 @@
+--- !ruby/object:Gem::Specification
+name: chat_sdk-x
+version: !ruby/object:Gem::Version
+  version: 0.3.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: X (Twitter) bot adapter for the ChatSDK framework
+email:
+- quentin@rootly.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/chat_sdk/x.rb
+- lib/chat_sdk/x/adapter.rb
+- lib/chat_sdk/x/api_client.rb
+- lib/chat_sdk/x/event_parser.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: X adapter for ChatSDK
+test_files: []