chat_sdk-discord 0.2.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: f3c068b8a4ec22b48a3e677299e12b777dd836f60de1775a91c50b914c5fc574
+  data.tar.gz: 8201aba74defacec745d0096e46eede4dd9c5fd0efeb4fe595c2a2cd695b9913
+SHA512:
+  metadata.gz: a50e09acc0f29e76140e1019db6044b46864064360aaecab313fd9a3781df41ddfce5f8a21787327a4927329c32ba727d891f62758a96dcde62d8c30c9946d02
+  data.tar.gz: af622c3cf1dbfd417fa85ea7f0313721e7580d43e365914246c6ae15f4abad0ae5aae77615a114fca29269545a68e218f71c263d2f2964247c045559b21fb53d

data/lib/chat_sdk/discord/adapter.rb

@@ -0,0 +1,205 @@
+# frozen_string_literal: true
+
+require "erb"
+
+module ChatSDK
+  module Discord
+    class Adapter < ChatSDK::Adapter::Base
+      capabilities :edit_messages, :delete_messages, :reactions, :file_uploads,
+        :threads, :direct_messages, :message_history, :streaming_edit
+
+      attr_reader :client
+
+      def initialize(bot_token: nil, public_key: nil, application_id: nil)
+        @bot_token = bot_token || ENV["DISCORD_BOT_TOKEN"]
+        @public_key = public_key || ENV["DISCORD_PUBLIC_KEY"]
+        @application_id = application_id || ENV["DISCORD_APPLICATION_ID"]
+
+        raise ChatSDK::ConfigurationError, "Discord bot_token required" unless @bot_token
+
+        @client = ApiClient.new(bot_token: @bot_token)
+        @renderer = EmbedRenderer.new
+      end
+
+      def name
+        :discord
+      end
+
+      # Inbound
+      def verify_request!(rack_request)
+        body = rack_request.body.read
+        rack_request.body.rewind
+
+        unless @public_key
+          raise ChatSDK::ConfigurationError, "Discord public_key required for signature verification"
+        end
+
+        signature = rack_request.get_header("HTTP_X_SIGNATURE_ED25519")
+        timestamp = rack_request.get_header("HTTP_X_SIGNATURE_TIMESTAMP")
+
+        unless signature && timestamp
+          raise ChatSDK::SignatureVerificationError, "Missing Discord signature headers"
+        end
+
+        Signature.verify!(@public_key, signature, timestamp, body)
+      end
+
+      def ack_response(rack_request)
+        body = rack_request.body.read
+        rack_request.body.rewind
+
+        payload = begin
+          JSON.parse(body)
+        rescue JSON::ParserError
+          return nil
+        end
+
+        return nil unless payload["type"] == 1
+
+        [200, {"content-type" => "application/json"}, ['{"type":1}']]
+      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)
+        msg = ChatSDK::PostableMessage.from(message)
+
+        content = msg.text || msg.card&.fallback_text || ""
+        embeds = nil
+        components = nil
+
+        if msg.card?
+          rendered = @renderer.render(msg.card)
+          embeds = rendered["embeds"]
+          components = rendered["components"]
+        end
+
+        result = @client.create_message(
+          channel_id,
+          content: content,
+          embeds: embeds,
+          components: components
+        )
+
+        ChatSDK::Message.new(
+          id: result["id"],
+          text: content,
+          author: ChatSDK::Author.new(id: @application_id || "bot", name: "bot", platform: :discord, bot: true),
+          thread_id: thread_id || result["id"],
+          channel_id: channel_id,
+          platform: :discord,
+          raw: result
+        )
+      end
+
+      def edit_message(channel_id:, message_id:, message:)
+        require_capability!(:edit_messages)
+        msg = ChatSDK::PostableMessage.from(message)
+
+        content = msg.text || msg.card&.fallback_text || ""
+        embeds = nil
+        components = nil
+
+        if msg.card?
+          rendered = @renderer.render(msg.card)
+          embeds = rendered["embeds"]
+          components = rendered["components"]
+        end
+
+        @client.edit_message(
+          channel_id,
+          message_id,
+          content: content,
+          embeds: embeds,
+          components: components
+        )
+      end
+
+      def delete_message(channel_id:, message_id:)
+        require_capability!(:delete_messages)
+        @client.delete_message(channel_id, message_id)
+      end
+
+      def post_ephemeral(channel_id:, user_id:, message:, thread_id: nil)
+        super # raises NotSupportedError
+      end
+
+      def upload_file(channel_id:, io:, filename:, thread_id: nil, comment: nil)
+        require_capability!(:file_uploads)
+        @client.upload_file(channel_id, io, filename)
+      end
+
+      def add_reaction(channel_id:, message_id:, emoji:)
+        require_capability!(:reactions)
+        @client.add_reaction(channel_id, message_id, emoji)
+      end
+
+      def remove_reaction(channel_id:, message_id:, emoji:)
+        require_capability!(:reactions)
+        @client.remove_reaction(channel_id, message_id, emoji)
+      end
+
+      def open_dm(user_id)
+        require_capability!(:direct_messages)
+        result = @client.create_dm(user_id)
+        result["id"]
+      end
+
+      def fetch_messages(channel_id:, thread_id: nil, cursor: nil, limit: 50)
+        require_capability!(:message_history)
+
+        messages_data = @client.get_messages(channel_id, limit: limit, before: cursor)
+        messages_data = [] unless messages_data.is_a?(Array)
+
+        messages = messages_data.map do |msg|
+          ChatSDK::Message.new(
+            id: msg["id"],
+            text: msg["content"] || "",
+            author: ChatSDK::Author.new(
+              id: msg.dig("author", "id") || "unknown",
+              name: msg.dig("author", "username") || "unknown",
+              platform: :discord
+            ),
+            thread_id: msg["id"],
+            channel_id: channel_id,
+            platform: :discord,
+            raw: msg
+          )
+        end
+
+        next_cursor = messages_data.any? ? messages_data.last["id"] : nil
+        [messages, next_cursor]
+      end
+
+      def open_modal(trigger_id:, modal:)
+        super # raises NotSupportedError
+      end
+
+      def start_typing(channel_id:, thread_id: nil)
+        super # raises NotSupportedError
+      end
+
+      def mention(user_id)
+        "<@#{user_id}>"
+      end
+
+      def render(postable_message)
+        msg = ChatSDK::PostableMessage.from(postable_message)
+        if msg.card?
+          @renderer.render(msg.card)
+        else
+          msg.text
+        end
+      end
+    end
+  end
+end

data/lib/chat_sdk/discord/api_client.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+module ChatSDK
+  module Discord
+    class ApiClient
+      BASE_URL = "https://discord.com"
+      API_PREFIX = "/api/v10"
+
+      def initialize(bot_token:)
+        @bot_token = bot_token
+      end
+
+      # Messages
+      def create_message(channel_id, content: nil, embeds: nil, components: nil)
+        body = {}
+        body["content"] = content if content
+        body["embeds"] = embeds if embeds
+        body["components"] = components if components
+        request(:post, "#{API_PREFIX}/channels/#{channel_id}/messages", body)
+      end
+
+      def edit_message(channel_id, message_id, content: nil, embeds: nil, components: nil)
+        body = {}
+        body["content"] = content if content
+        body["embeds"] = embeds if embeds
+        body["components"] = components if components
+        request(:patch, "#{API_PREFIX}/channels/#{channel_id}/messages/#{message_id}", body)
+      end
+
+      def delete_message(channel_id, message_id)
+        request(:delete, "#{API_PREFIX}/channels/#{channel_id}/messages/#{message_id}")
+      end
+
+      # Reactions
+      def add_reaction(channel_id, message_id, emoji)
+        encoded = ERB::Util.url_encode(emoji)
+        request(:put, "#{API_PREFIX}/channels/#{channel_id}/messages/#{message_id}/reactions/#{encoded}/@me")
+      end
+
+      def remove_reaction(channel_id, message_id, emoji)
+        encoded = ERB::Util.url_encode(emoji)
+        request(:delete, "#{API_PREFIX}/channels/#{channel_id}/messages/#{message_id}/reactions/#{encoded}/@me")
+      end
+
+      # DMs
+      def create_dm(user_id)
+        request(:post, "#{API_PREFIX}/users/@me/channels", {"recipient_id" => user_id})
+      end
+
+      # Messages history
+      def get_messages(channel_id, limit: 50, before: nil)
+        path = "#{API_PREFIX}/channels/#{channel_id}/messages?limit=#{limit}"
+        path += "&before=#{before}" if before
+        request(:get, path)
+      end
+
+      # Typing
+      def trigger_typing(channel_id)
+        request(:post, "#{API_PREFIX}/channels/#{channel_id}/typing")
+      end
+
+      # File upload
+      def upload_file(channel_id, io, filename)
+        conn = Faraday.new(url: BASE_URL) do |f|
+          f.request :multipart
+          f.response :json
+          f.adapter :net_http
+        end
+
+        payload = {
+          "file[0]" => Faraday::Multipart::FilePart.new(io, "application/octet-stream", filename)
+        }
+
+        response = conn.post("#{API_PREFIX}/channels/#{channel_id}/messages", payload) do |req|
+          req.headers["Authorization"] = "Bot #{@bot_token}"
+        end
+
+        handle_response(response)
+      end
+
+      private
+
+      def connection
+        @connection ||= Faraday.new(url: BASE_URL) do |f|
+          f.request :json
+          f.response :json
+          f.adapter :net_http
+        end
+      end
+
+      def request(method, path, body = nil)
+        response = connection.public_send(method, path) do |req|
+          req.headers["Authorization"] = "Bot #{@bot_token}"
+          req.body = body if body && method != :get
+        end
+
+        handle_response(response)
+      end
+
+      def handle_response(response)
+        return response.body if response.success?
+
+        if response.status == 429
+          retry_after = response.body.is_a?(Hash) ? response.body["retry_after"]&.to_i : nil
+          raise ChatSDK::RateLimitedError.new(
+            "Discord API rate limited",
+            retry_after: retry_after,
+            status: response.status,
+            body: response.body,
+            adapter_name: :discord
+          )
+        end
+
+        raise ChatSDK::PlatformError.new(
+          "Discord API error: #{response.status}",
+          status: response.status,
+          body: response.body,
+          adapter_name: :discord
+        )
+      end
+    end
+  end
+end

data/lib/chat_sdk/discord/embed_renderer.rb

@@ -0,0 +1,155 @@
+# frozen_string_literal: true
+
+module ChatSDK
+  module Discord
+    class EmbedRenderer
+      def render(node)
+        case node.type
+        when :card then render_card(node)
+        else render_single(node)
+        end
+      end
+
+      private
+
+      def render_card(node)
+        embed = {}
+        description_parts = []
+        fields = []
+        components = []
+
+        embed["title"] = node.attributes[:title] if node.attributes[:title]
+
+        if node.attributes[:subtitle]
+          description_parts << node.attributes[:subtitle]
+        end
+
+        node.children.each do |child|
+          case child.type
+          when :text
+            description_parts << child.attributes[:content]
+          when :divider
+            description_parts << "───"
+          when :image
+            embed["image"] = {"url" => child.attributes[:url]}
+          when :fields
+            child.children.each do |field|
+              fields << {
+                "name" => field.attributes[:label],
+                "value" => field.attributes[:value],
+                "inline" => true
+              }
+            end
+          when :section
+            render_section_into(child, description_parts, fields, components)
+          when :actions
+            row = render_action_row(child)
+            components << row if row
+          when :button, :link_button, :select
+            row = {"type" => 1, "components" => [render_component(child)].compact}
+            components << row
+          end
+        end
+
+        embed["description"] = description_parts.join("\n") unless description_parts.empty?
+        embed["fields"] = fields unless fields.empty?
+
+        result = {"embeds" => [embed]}
+        result["components"] = components unless components.empty?
+        result
+      end
+
+      def render_section_into(node, description_parts, fields, components)
+        description_parts << "**#{node.attributes[:title]}**" if node.attributes[:title]
+
+        node.children.each do |child|
+          case child.type
+          when :text
+            description_parts << child.attributes[:content]
+          when :fields
+            child.children.each do |field|
+              fields << {
+                "name" => field.attributes[:label],
+                "value" => field.attributes[:value],
+                "inline" => true
+              }
+            end
+          when :actions
+            row = render_action_row(child)
+            components << row if row
+          when :button, :link_button, :select
+            row = {"type" => 1, "components" => [render_component(child)].compact}
+            components << row
+          end
+        end
+      end
+
+      def render_action_row(node)
+        comps = node.children.filter_map { |child| render_component(child) }
+        return nil if comps.empty?
+
+        {"type" => 1, "components" => comps}
+      end
+
+      def render_component(node)
+        case node.type
+        when :button then render_button(node)
+        when :link_button then render_link_button(node)
+        when :select then render_select(node)
+        end
+      end
+
+      def render_button(node)
+        style = case node.attributes[:style]
+        when :primary then 1
+        when :danger then 4
+        else 2
+        end
+
+        {
+          "type" => 2,
+          "style" => style,
+          "label" => node.attributes[:text],
+          "custom_id" => node.attributes[:id] || "button"
+        }
+      end
+
+      def render_link_button(node)
+        {
+          "type" => 2,
+          "style" => 5,
+          "label" => node.attributes[:text],
+          "url" => node.attributes[:url]
+        }
+      end
+
+      def render_select(node)
+        options = node.children.map do |opt|
+          option = {
+            "label" => opt.attributes[:text],
+            "value" => opt.attributes[:value]
+          }
+          option["description"] = opt.attributes[:description] if opt.attributes[:description]
+          option
+        end
+
+        component = {
+          "type" => 3,
+          "custom_id" => node.attributes[:id] || "select",
+          "options" => options
+        }
+        component["placeholder"] = node.attributes[:placeholder] if node.attributes[:placeholder]
+        component
+      end
+
+      def render_single(node)
+        case node.type
+        when :text
+          {"embeds" => [{"description" => node.attributes[:content]}]}
+        else
+          {"embeds" => [{"description" => node.fallback_text}]}
+        end
+      end
+    end
+  end
+end

data/lib/chat_sdk/discord/event_parser.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module ChatSDK
+  module Discord
+    class EventParser
+      class << self
+        def parse(payload)
+          return [] unless payload.is_a?(Hash)
+
+          type = payload["type"]
+          data = payload["data"] || {}
+
+          case type
+          when 1 # PING
+            []
+          when 2 # APPLICATION_COMMAND
+            parse_application_command(payload, data)
+          when 3 # MESSAGE_COMPONENT
+            parse_message_component(payload, data)
+          else
+            []
+          end
+        end
+
+        private
+
+        def parse_application_command(payload, data)
+          user_info = extract_user(payload)
+          channel_id = payload["channel_id"]
+          command = "/#{data["name"]}"
+          text = extract_options_text(data["options"])
+
+          [ChatSDK::Events::SlashCommand.new(
+            command: command,
+            text: text,
+            user_id: user_info[:id],
+            channel_id: channel_id,
+            trigger_id: payload["id"],
+            platform: :discord,
+            adapter_name: :discord,
+            raw: payload
+          )]
+        end
+
+        def parse_message_component(payload, data)
+          user_info = extract_user(payload)
+          channel_id = payload["channel_id"]
+          message_id = payload.dig("message", "id")
+
+          action_id = data["custom_id"]
+          value = if data["values"].is_a?(Array) && !data["values"].empty?
+            data["values"].first
+          else
+            data["custom_id"]
+          end
+
+          user = ChatSDK::Author.new(
+            id: user_info[:id],
+            name: user_info[:name],
+            platform: :discord,
+            bot: false
+          )
+
+          [ChatSDK::Events::Action.new(
+            action_id: action_id,
+            value: value,
+            user: user,
+            thread_id: message_id,
+            channel_id: channel_id,
+            platform: :discord,
+            adapter_name: :discord,
+            raw: payload
+          )]
+        end
+
+        def extract_user(payload)
+          user = payload.dig("member", "user") || payload["user"] || {}
+          {
+            id: user["id"] || "unknown",
+            name: user["username"] || user["id"] || "unknown"
+          }
+        end
+
+        def extract_options_text(options)
+          return "" unless options.is_a?(Array)
+
+          options.filter_map { |opt| opt["value"]&.to_s }.join(" ")
+        end
+      end
+    end
+  end
+end

data/lib/chat_sdk/discord/signature.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module ChatSDK
+  module Discord
+    module Signature
+      def self.verify!(public_key_hex, signature_hex, timestamp, body)
+        verify_key = Ed25519::VerifyKey.new([public_key_hex].pack("H*"))
+        signature = [signature_hex].pack("H*")
+        message = "#{timestamp}#{body}"
+        verify_key.verify(signature, message)
+        true
+      rescue Ed25519::VerifyError, ArgumentError
+        raise ChatSDK::SignatureVerificationError, "Invalid Discord signature"
+      end
+    end
+  end
+end

data/lib/chat_sdk/discord.rb

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

metadata

@@ -0,0 +1,89 @@
+--- !ruby/object:Gem::Specification
+name: chat_sdk-discord
+version: !ruby/object:Gem::Version
+  version: 0.2.1
+platform: ruby
+authors:
+- Rootly
+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'
+- !ruby/object:Gem::Dependency
+  name: ed25519
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+description: Discord bot adapter for the ChatSDK framework
+email:
+- eng@rootly.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/chat_sdk/discord.rb
+- lib/chat_sdk/discord/adapter.rb
+- lib/chat_sdk/discord/api_client.rb
+- lib/chat_sdk/discord/embed_renderer.rb
+- lib/chat_sdk/discord/event_parser.rb
+- lib/chat_sdk/discord/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: Discord adapter for ChatSDK
+test_files: []