chat_sdk-slack 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: d6e4e9dd2243b38d51bcdd10278e9f59ac540e01f7340ece7585d63475c59e06
+  data.tar.gz: 2f7a0a47486dcfa63cd3be0c4784ba70f5d8f973beed2b276b4ce10aebb5a242
+SHA512:
+  metadata.gz: c1d6bc38dc2635d2e737c915f2eb24c32c16f0c9ed7792af675769ddebbe3e14de8b679c28566ca9e5655b4332860a58424aa5bff6901eaa3120baf17051c80b
+  data.tar.gz: 9f3af6fb31887b727e0ff1b9bbfcabdb57e9dc1008b915f4b25ae13a7ef22c794ea5042a42d7117c31b990233dfdc69de819e642d55b581f57dfa2d3b7fb80f4

data/lib/chat_sdk/slack/adapter.rb

@@ -0,0 +1,231 @@
+# frozen_string_literal: true
+
+module ChatSDK
+  module Slack
+    class Adapter < ChatSDK::Adapter::Base
+      capabilities :edit_messages, :delete_messages, :ephemeral_messages,
+        :file_uploads, :reactions, :modals, :typing_indicator,
+        :streaming_edit, :threads, :direct_messages, :message_history
+
+      attr_reader :client
+
+      def initialize(bot_token: nil, signing_secret: nil)
+        @bot_token = bot_token || ENV["SLACK_BOT_TOKEN"]
+        @signing_secret = signing_secret || ENV["SLACK_SIGNING_SECRET"]
+
+        raise ChatSDK::ConfigurationError, "Slack bot_token required" unless @bot_token
+        raise ChatSDK::ConfigurationError, "Slack signing_secret required" unless @signing_secret
+
+        ::Slack.configure do |config|
+          config.token = @bot_token
+        end
+
+        @client = ::Slack::Web::Client.new(token: @bot_token)
+        @renderer = BlockKitRenderer.new
+        @modal_renderer = ModalRenderer.new
+      end
+
+      def name
+        :slack
+      end
+
+      # Inbound
+      def verify_request!(rack_request)
+        body = rack_request.body.read
+        rack_request.body.rewind
+        timestamp = rack_request.env["HTTP_X_SLACK_REQUEST_TIMESTAMP"]
+        signature = rack_request.env["HTTP_X_SLACK_SIGNATURE"]
+
+        raise ChatSDK::SignatureVerificationError, "Missing Slack signature headers" unless timestamp && signature
+
+        sig_basestring = "v0:#{timestamp}:#{body}"
+        hex_digest = OpenSSL::HMAC.hexdigest("SHA256", @signing_secret, sig_basestring)
+        computed = "v0=#{hex_digest}"
+
+        unless Rack::Utils.secure_compare(computed, signature)
+          raise ChatSDK::SignatureVerificationError, "Invalid Slack signature"
+        end
+
+        age = Time.now.to_i - timestamp.to_i
+        if age.abs > 300
+          raise ChatSDK::SignatureVerificationError, "Slack request too old (#{age}s)"
+        end
+
+        true
+      end
+
+      def ack_response(rack_request)
+        body = rack_request.body.read
+        rack_request.body.rewind
+
+        parsed = parse_body(body, rack_request.content_type)
+        return nil unless parsed
+
+        if parsed["type"] == "url_verification"
+          [200, {"content-type" => "text/plain"}, [parsed["challenge"]]]
+        end
+      end
+
+      def parse_events(rack_request)
+        body = rack_request.body.read
+        rack_request.body.rewind
+
+        parsed = parse_body(body, rack_request.content_type)
+        return [] unless parsed
+
+        EventParser.parse(parsed)
+      end
+
+      # Outbound
+      def post_message(channel_id:, message:, thread_id: nil)
+        msg = ChatSDK::PostableMessage.from(message)
+        params = {channel: channel_id}
+        params[:thread_ts] = thread_id if thread_id
+
+        if msg.card?
+          rendered = @renderer.render(msg.card)
+          params[:blocks] = rendered
+          params[:text] = msg.text || msg.card.fallback_text
+        else
+          params[:text] = msg.text
+        end
+
+        result = @client.chat_postMessage(**params)
+
+        ChatSDK::Message.new(
+          id: result["ts"],
+          text: msg.text || "",
+          author: ChatSDK::Author.new(id: "bot", name: "bot", platform: :slack, bot: true),
+          thread_id: thread_id || result["ts"],
+          channel_id: channel_id,
+          platform: :slack,
+          raw: result
+        )
+      end
+
+      def edit_message(channel_id:, message_id:, message:)
+        msg = ChatSDK::PostableMessage.from(message)
+        params = {channel: channel_id, ts: message_id}
+
+        if msg.card?
+          params[:blocks] = @renderer.render(msg.card)
+          params[:text] = msg.text || msg.card.fallback_text
+        else
+          params[:text] = msg.text
+        end
+
+        @client.chat_update(**params)
+      end
+
+      def delete_message(channel_id:, message_id:)
+        @client.chat_delete(channel: channel_id, ts: message_id)
+      end
+
+      def post_ephemeral(channel_id:, user_id:, message:, thread_id: nil)
+        msg = ChatSDK::PostableMessage.from(message)
+        params = {channel: channel_id, user: user_id}
+        params[:thread_ts] = thread_id if thread_id
+
+        if msg.card?
+          params[:blocks] = @renderer.render(msg.card)
+          params[:text] = msg.text || msg.card.fallback_text
+        else
+          params[:text] = msg.text
+        end
+
+        @client.chat_postEphemeral(**params)
+      end
+
+      def upload_file(channel_id:, io:, filename:, thread_id: nil, comment: nil)
+        params = {channels: channel_id, file: Faraday::Multipart::FilePart.new(io, nil, filename)}
+        params[:thread_ts] = thread_id if thread_id
+        params[:initial_comment] = comment if comment
+        @client.files_upload(**params)
+      end
+
+      def add_reaction(channel_id:, message_id:, emoji:)
+        @client.reactions_add(channel: channel_id, timestamp: message_id, name: emoji)
+      end
+
+      def remove_reaction(channel_id:, message_id:, emoji:)
+        @client.reactions_remove(channel: channel_id, timestamp: message_id, name: emoji)
+      end
+
+      def open_dm(user_id)
+        result = @client.conversations_open(users: user_id)
+        result["channel"]["id"]
+      end
+
+      def fetch_messages(channel_id:, thread_id: nil, cursor: nil, limit: 50)
+        result = if thread_id
+          @client.conversations_replies(channel: channel_id, ts: thread_id, cursor: cursor, limit: limit)
+        else
+          @client.conversations_history(channel: channel_id, cursor: cursor, limit: limit)
+        end
+        messages = result["messages"].map { |m| parse_slack_message(m, channel_id) }
+        [messages, result["response_metadata"]&.dig("next_cursor")]
+      end
+
+      def open_modal(trigger_id:, modal:)
+        view = @modal_renderer.render(modal)
+        @client.views_open(trigger_id: trigger_id, view: view)
+      end
+
+      def start_typing(channel_id:, thread_id: nil)
+        # Slack doesn't have a native typing indicator API for bots
+        # This is a no-op but the capability is declared for streaming support
+      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 parse_body(body, content_type)
+        if content_type&.include?("application/json")
+          JSON.parse(body)
+        elsif content_type&.include?("application/x-www-form-urlencoded")
+          params = Rack::Utils.parse_query(body)
+          if params["payload"]
+            JSON.parse(params["payload"])
+          else
+            params
+          end
+        else
+          begin
+            JSON.parse(body)
+          rescue JSON::ParserError
+            nil
+          end
+        end
+      end
+
+      def parse_slack_message(data, channel_id)
+        ChatSDK::Message.new(
+          id: data["ts"],
+          text: data["text"] || "",
+          author: ChatSDK::Author.new(
+            id: data["user"] || data["bot_id"] || "unknown",
+            name: data["username"] || data["user"] || "unknown",
+            platform: :slack,
+            bot: !!data["bot_id"]
+          ),
+          thread_id: data["thread_ts"] || data["ts"],
+          channel_id: channel_id,
+          platform: :slack,
+          timestamp: data["ts"],
+          raw: data
+        )
+      end
+    end
+  end
+end

data/lib/chat_sdk/slack/block_kit_renderer.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+module ChatSDK
+  module Slack
+    class BlockKitRenderer
+      def render(node)
+        case node.type
+        when :card then render_card(node)
+        else [render_node(node)]
+        end
+      end
+
+      private
+
+      def render_card(node)
+        node.children.map { |child| render_node(child) }.compact
+      end
+
+      def render_node(node)
+        case node.type
+        when :text then render_text(node)
+        when :divider then {type: "divider"}
+        when :image then render_image(node)
+        when :fields then render_fields(node)
+        when :section then render_section(node)
+        when :actions then render_actions(node)
+        end
+      end
+
+      def render_text(node)
+        {
+          type: "section",
+          text: {type: "mrkdwn", text: node.attributes[:content]}
+        }
+      end
+
+      def render_image(node)
+        block = {type: "image", image_url: node.attributes[:url]}
+        block[:alt_text] = node.attributes[:alt] || " "
+        block
+      end
+
+      def render_fields(node)
+        {
+          type: "section",
+          fields: node.children.map do |field|
+            {type: "mrkdwn", text: "*#{field.attributes[:label]}*\n#{field.attributes[:value]}"}
+          end
+        }
+      end
+
+      def render_section(node)
+        block = {type: "section"}
+        text_children = node.children.select { |c| c.type == :text }
+        if text_children.any?
+          block[:text] = {type: "mrkdwn", text: text_children.map { |t| t.attributes[:content] }.join("\n")}
+        end
+        block
+      end
+
+      def render_actions(node)
+        {
+          type: "actions",
+          elements: node.children.map { |child| render_action_element(child) }.compact
+        }
+      end
+
+      def render_action_element(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)
+        btn = {
+          type: "button",
+          text: {type: "plain_text", text: node.attributes[:text]},
+          action_id: node.attributes[:id]
+        }
+        btn[:value] = node.attributes[:value] if node.attributes[:value]
+        if node.attributes[:style] == :primary
+          btn[:style] = "primary"
+        elsif node.attributes[:style] == :danger
+          btn[:style] = "danger"
+        end
+        btn
+      end
+
+      def render_link_button(node)
+        {
+          type: "button",
+          text: {type: "plain_text", text: node.attributes[:text]},
+          url: node.attributes[:url],
+          action_id: "link_#{node.attributes[:url].hash.abs}"
+        }
+      end
+
+      def render_select(node)
+        sel = {
+          type: "static_select",
+          action_id: node.attributes[:id],
+          options: node.children.map { |opt| render_option(opt) }
+        }
+        if node.attributes[:placeholder]
+          sel[:placeholder] = {type: "plain_text", text: node.attributes[:placeholder]}
+        end
+        sel
+      end
+
+      def render_option(node)
+        opt = {
+          text: {type: "plain_text", text: node.attributes[:text]},
+          value: node.attributes[:value]
+        }
+        if node.attributes[:description]
+          opt[:description] = {type: "plain_text", text: node.attributes[:description]}
+        end
+        opt
+      end
+    end
+  end
+end

data/lib/chat_sdk/slack/event_parser.rb

@@ -0,0 +1,171 @@
+# frozen_string_literal: true
+
+module ChatSDK
+  module Slack
+    class EventParser
+      class << self
+        def parse(payload)
+          case payload["type"]
+          when "event_callback"
+            parse_event_callback(payload)
+          when "block_actions", "interactive_message"
+            parse_block_actions(payload)
+          when "view_submission"
+            parse_view_submission(payload)
+          when "slash_commands"
+            parse_slash_command(payload)
+          else
+            # Slash commands come as form-encoded, not wrapped in type
+            if payload["command"]
+              parse_slash_command(payload)
+            else
+              []
+            end
+          end
+        end
+
+        private
+
+        def parse_event_callback(payload)
+          event = payload["event"]
+          return [] unless event
+
+          case event["type"]
+          when "app_mention"
+            parse_mention(event, payload)
+          when "message"
+            parse_message_event(event, payload)
+          when "reaction_added"
+            parse_reaction(event, payload, added: true)
+          when "reaction_removed"
+            parse_reaction(event, payload, added: false)
+          else
+            []
+          end
+        end
+
+        def parse_mention(event, payload)
+          author = ChatSDK::Author.new(
+            id: event["user"],
+            name: event["user"],
+            platform: :slack
+          )
+          message = ChatSDK::Message.new(
+            id: event["ts"],
+            text: event["text"] || "",
+            author: author,
+            thread_id: event["thread_ts"] || event["ts"],
+            channel_id: event["channel"],
+            platform: :slack,
+            raw: event
+          )
+          [ChatSDK::Events::Mention.new(
+            message: message,
+            thread_id: event["thread_ts"] || event["ts"],
+            channel_id: event["channel"],
+            platform: :slack,
+            adapter_name: :slack,
+            raw: payload
+          )]
+        end
+
+        def parse_message_event(event, payload)
+          return [] if event["subtype"] && event["subtype"] != "file_share"
+          return [] if event["bot_id"]
+
+          author = ChatSDK::Author.new(
+            id: event["user"],
+            name: event["user"],
+            platform: :slack
+          )
+          message = ChatSDK::Message.new(
+            id: event["ts"],
+            text: event["text"] || "",
+            author: author,
+            thread_id: event["thread_ts"] || event["ts"],
+            channel_id: event["channel"],
+            platform: :slack,
+            raw: event
+          )
+
+          channel_type = event["channel_type"]
+          if channel_type == "im"
+            [ChatSDK::Events::DirectMessage.new(
+              message: message,
+              thread_id: event["thread_ts"] || event["ts"],
+              channel_id: event["channel"],
+              platform: :slack,
+              adapter_name: :slack,
+              raw: payload
+            )]
+          else
+            [ChatSDK::Events::SubscribedMessage.new(
+              message: message,
+              thread_id: event["thread_ts"] || event["ts"],
+              channel_id: event["channel"],
+              platform: :slack,
+              adapter_name: :slack,
+              raw: payload
+            )]
+          end
+        end
+
+        def parse_reaction(event, payload, added:)
+          [ChatSDK::Events::Reaction.new(
+            emoji: event["reaction"],
+            user_id: event["user"],
+            message_id: event.dig("item", "ts"),
+            thread_id: event.dig("item", "ts"),
+            channel_id: event.dig("item", "channel"),
+            added: added,
+            platform: :slack,
+            adapter_name: :slack,
+            raw: payload
+          )]
+        end
+
+        def parse_block_actions(payload)
+          actions = payload["actions"] || []
+          user = payload["user"]
+          channel = payload.dig("channel", "id")
+          message_ts = payload.dig("message", "ts")
+          thread_ts = payload.dig("message", "thread_ts") || message_ts
+          trigger_id = payload["trigger_id"]
+
+          actions.map do |action|
+            ChatSDK::Events::Action.new(
+              action_id: action["action_id"],
+              value: action["value"] || action.dig("selected_option", "value"),
+              user: ChatSDK::Author.new(id: user["id"], name: user["name"] || user["id"], platform: :slack),
+              thread_id: thread_ts,
+              channel_id: channel,
+              trigger_id: trigger_id,
+              platform: :slack,
+              adapter_name: :slack,
+              raw: payload
+            )
+          end
+        end
+
+        def parse_view_submission(payload)
+          # View submissions are handled differently - return empty for now
+          # They'll be handled via on_modal_submit in a future version
+          []
+        end
+
+        def parse_slash_command(payload)
+          [ChatSDK::Events::SlashCommand.new(
+            command: payload["command"],
+            text: payload["text"] || "",
+            user_id: payload["user_id"],
+            channel_id: payload["channel_id"],
+            trigger_id: payload["trigger_id"],
+            platform: :slack,
+            adapter_name: :slack,
+            raw: payload
+          )]
+        end
+      end
+    end
+  end
+end

data/lib/chat_sdk/slack/modal_renderer.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module ChatSDK
+  module Slack
+    class ModalRenderer
+      def render(node)
+        view = {
+          type: "modal",
+          title: {type: "plain_text", text: node.attributes[:title]}
+        }
+        view[:callback_id] = node.attributes[:callback_id] if node.attributes[:callback_id]
+        if node.attributes[:submit_label]
+          view[:submit] = {type: "plain_text", text: node.attributes[:submit_label]}
+        end
+        view[:blocks] = node.children.map { |child| render_block(child) }.compact
+        view
+      end
+
+      private
+
+      def render_block(node)
+        case node.type
+        when :input then render_input(node)
+        when :text then render_text(node)
+        end
+      end
+
+      def render_input(node)
+        block = {
+          type: "input",
+          block_id: node.attributes[:id],
+          label: {type: "plain_text", text: node.attributes[:label]},
+          optional: node.attributes[:optional] || false
+        }
+        block[:element] = case node.attributes[:input_type]
+        when :text
+          el = {
+            type: "plain_text_input",
+            action_id: node.attributes[:id],
+            multiline: !!node.attributes[:multiline]
+          }
+          el[:placeholder] = {type: "plain_text", text: node.attributes[:placeholder]} if node.attributes[:placeholder]
+          el
+        when :select
+          el = {
+            type: "static_select",
+            action_id: node.attributes[:id],
+            options: node.children.map { |opt| render_option(opt) }
+          }
+          el[:placeholder] = {type: "plain_text", text: node.attributes[:placeholder]} if node.attributes[:placeholder]
+          el
+        end
+        block
+      end
+
+      def render_text(node)
+        {
+          type: "section",
+          text: {type: "mrkdwn", text: node.attributes[:content]}
+        }
+      end
+
+      def render_option(node)
+        opt = {
+          text: {type: "plain_text", text: node.attributes[:text]},
+          value: node.attributes[:value]
+        }
+        opt[:description] = {type: "plain_text", text: node.attributes[:description]} if node.attributes[:description]
+        opt
+      end
+    end
+  end
+end

data/lib/chat_sdk/slack.rb

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

metadata

@@ -0,0 +1,74 @@
+--- !ruby/object:Gem::Specification
+name: chat_sdk-slack
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+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: slack-ruby-client
+  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: Slack bot adapter for the ChatSDK framework using slack-ruby-client
+email:
+- eng@rootly.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/chat_sdk/slack.rb
+- lib/chat_sdk/slack/adapter.rb
+- lib/chat_sdk/slack/block_kit_renderer.rb
+- lib/chat_sdk/slack/event_parser.rb
+- lib/chat_sdk/slack/modal_renderer.rb
+homepage: https://github.com/rootlyhq/rootly-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: Slack adapter for ChatSDK
+test_files: []