chat_sdk-mattermost 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 858c54b49dd67ec3850a0d5896598be9c58794a2f2fdd6ee07233f7f20ff13fb
+  data.tar.gz: 0071f01c237e90e2ac85a2d12cb3917b83869a75a4115fa11a6aa22f0ee476dc
+SHA512:
+  metadata.gz: 8100e0c6256b3e21dd9a1bbf4a16f4c7acd61130b4df064a1142148876456ea2c1e25a1dcd7716bca9bfbe51a068300d773175aa6b20c0872fd9000472eee1d6
+  data.tar.gz: a05820710ee8e3fbdfdc74eb9f45e40c123212b870f1b57a1c56ac0267146073dc0756f4b9d738bcd401ebaed311916fb4f146342b49555457f4f07936422fd4

data/lib/chat_sdk/mattermost/adapter.rb

@@ -0,0 +1,226 @@
+# frozen_string_literal: true
+
+require "rack/utils"
+
+module ChatSDK
+  module Mattermost
+    class Adapter < ChatSDK::Adapter::Base
+      capabilities :edit_messages, :delete_messages, :ephemeral_messages, :reactions,
+        :typing_indicator, :streaming_edit, :threads, :direct_messages,
+        :message_history, :file_uploads
+
+      attr_reader :client
+
+      def initialize(base_url: nil, bot_token: nil, webhook_token: nil, bot_user_id: nil)
+        @base_url = base_url || ENV["MATTERMOST_BASE_URL"]
+        @bot_token = bot_token || ENV["MATTERMOST_BOT_TOKEN"]
+        @webhook_token = webhook_token || ENV["MATTERMOST_WEBHOOK_TOKEN"]
+        @bot_user_id = bot_user_id || ENV["MATTERMOST_BOT_USER_ID"]
+
+        raise ChatSDK::ConfigurationError, "Mattermost base_url required" unless @base_url
+        raise ChatSDK::ConfigurationError, "Mattermost bot_token required" unless @bot_token
+
+        @client = ApiClient.new(base_url: @base_url, bot_token: @bot_token)
+        @renderer = AttachmentRenderer.new
+      end
+
+      def name
+        :mattermost
+      end
+
+      # Inbound
+      def verify_request!(rack_request)
+        body = rack_request.body.read
+        rack_request.body.rewind
+
+        payload = begin
+          JSON.parse(body)
+        rescue JSON::ParserError
+          raise ChatSDK::SignatureVerificationError, "Invalid JSON payload"
+        end
+
+        return true unless @webhook_token
+
+        token = payload["token"]
+        unless token && Rack::Utils.secure_compare(token, @webhook_token)
+          raise ChatSDK::SignatureVerificationError, "Invalid webhook token"
+        end
+
+        true
+      end
+
+      def parse_events(rack_request)
+        body = rack_request.body.read
+        rack_request.body.rewind
+
+        payload = JSON.parse(body)
+        EventParser.parse(payload, bot_user_id: @bot_user_id)
+      rescue JSON::ParserError
+        []
+      end
+
+      # Outbound
+      def post_message(channel_id:, message:, thread_id: nil)
+        msg = ChatSDK::PostableMessage.from(message)
+
+        props = nil
+        if msg.card?
+          attachments = @renderer.render(msg.card)
+          props = {"attachments" => attachments}
+        end
+
+        result = @client.create_post(
+          channel_id: channel_id,
+          message: msg.text || msg.card&.fallback_text || "",
+          root_id: thread_id,
+          props: props
+        )
+
+        ChatSDK::Message.new(
+          id: result["id"],
+          text: msg.text || "",
+          author: ChatSDK::Author.new(id: @bot_user_id || "bot", name: "bot", platform: :mattermost, bot: true),
+          thread_id: thread_id || result["id"],
+          channel_id: channel_id,
+          platform: :mattermost,
+          raw: result
+        )
+      end
+
+      def edit_message(channel_id:, message_id:, message:)
+        require_capability!(:edit_messages)
+        msg = ChatSDK::PostableMessage.from(message)
+
+        props = nil
+        if msg.card?
+          attachments = @renderer.render(msg.card)
+          props = {"attachments" => attachments}
+        end
+
+        @client.update_post(
+          post_id: message_id,
+          message: msg.text || msg.card&.fallback_text || "",
+          props: props
+        )
+      end
+
+      def delete_message(channel_id:, message_id:)
+        require_capability!(:delete_messages)
+        @client.delete_post(post_id: message_id)
+      end
+
+      def post_ephemeral(channel_id:, user_id:, message:, thread_id: nil)
+        require_capability!(:ephemeral_messages)
+        msg = ChatSDK::PostableMessage.from(message)
+        @client.create_ephemeral_post(
+          user_id: user_id,
+          channel_id: channel_id,
+          message: msg.text || msg.card&.fallback_text || ""
+        )
+      end
+
+      def upload_file(channel_id:, io:, filename:, thread_id: nil, comment: nil)
+        require_capability!(:file_uploads)
+
+        file_result = @client.upload_file(channel_id: channel_id, io: io, filename: filename)
+        file_ids = file_result.dig("file_infos")&.map { |fi| fi["id"] } || []
+
+        @client.create_post(
+          channel_id: channel_id,
+          message: comment || "",
+          root_id: thread_id,
+          props: nil,
+          file_ids: file_ids
+        )
+      end
+
+      def add_reaction(channel_id:, message_id:, emoji:)
+        require_capability!(:reactions)
+        raise ChatSDK::ConfigurationError, "bot_user_id required for reactions" unless @bot_user_id
+
+        @client.add_reaction(
+          user_id: @bot_user_id,
+          post_id: message_id,
+          emoji_name: emoji
+        )
+      end
+
+      def remove_reaction(channel_id:, message_id:, emoji:)
+        require_capability!(:reactions)
+        raise ChatSDK::ConfigurationError, "bot_user_id required for reactions" unless @bot_user_id
+
+        @client.remove_reaction(
+          user_id: @bot_user_id,
+          post_id: message_id,
+          emoji_name: emoji
+        )
+      end
+
+      def open_dm(user_id)
+        require_capability!(:direct_messages)
+        raise ChatSDK::ConfigurationError, "bot_user_id required for DMs" unless @bot_user_id
+
+        result = @client.create_direct_channel([@bot_user_id, user_id])
+        result["id"]
+      end
+
+      def fetch_messages(channel_id:, thread_id: nil, cursor: nil, limit: 50)
+        require_capability!(:message_history)
+
+        if thread_id
+          result = @client.get_post_thread(post_id: thread_id)
+        else
+          page = cursor&.to_i || 0
+          result = @client.get_channel_posts(channel_id: channel_id, page: page, per_page: limit)
+        end
+
+        order = result["order"] || []
+        posts = result["posts"] || {}
+
+        messages = order.map do |post_id|
+          post = posts[post_id]
+          next unless post
+
+          ChatSDK::Message.new(
+            id: post["id"],
+            text: post["message"] || "",
+            author: ChatSDK::Author.new(
+              id: post["user_id"] || "unknown",
+              name: post["user_id"] || "unknown",
+              platform: :mattermost
+            ),
+            thread_id: post["root_id"].to_s.empty? ? post["id"] : post["root_id"],
+            channel_id: post["channel_id"],
+            platform: :mattermost,
+            raw: post
+          )
+        end.compact
+
+        next_cursor = thread_id ? nil : ((cursor&.to_i || 0) + 1).to_s
+        [messages, next_cursor]
+      end
+
+      def open_modal(trigger_id:, modal:)
+        super # raises NotSupportedError
+      end
+
+      def start_typing(channel_id:, thread_id: nil)
+        require_capability!(:typing_indicator)
+        @client.send_typing(channel_id: channel_id)
+      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/mattermost/api_client.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+module ChatSDK
+  module Mattermost
+    class ApiClient
+      attr_reader :base_url
+
+      def initialize(base_url:, bot_token:)
+        @base_url = base_url.chomp("/")
+        @bot_token = bot_token
+      end
+
+      # Posts
+      def create_post(channel_id:, message:, root_id: nil, props: nil, file_ids: nil)
+        body = {"channel_id" => channel_id, "message" => message}
+        body["root_id"] = root_id if root_id
+        body["props"] = props if props
+        body["file_ids"] = file_ids if file_ids
+        request(:post, "/api/v4/posts", body)
+      end
+
+      def update_post(post_id:, message:, props: nil)
+        body = {"id" => post_id, "message" => message}
+        body["props"] = props if props
+        request(:put, "/api/v4/posts/#{post_id}", body)
+      end
+
+      def delete_post(post_id:)
+        request(:delete, "/api/v4/posts/#{post_id}")
+      end
+
+      def create_ephemeral_post(user_id:, channel_id:, message:)
+        body = {
+          "user_id" => user_id,
+          "post" => {"channel_id" => channel_id, "message" => message}
+        }
+        request(:post, "/api/v4/posts/ephemeral", body)
+      end
+
+      # Reactions
+      def add_reaction(user_id:, post_id:, emoji_name:)
+        body = {"user_id" => user_id, "post_id" => post_id, "emoji_name" => emoji_name}
+        request(:post, "/api/v4/reactions", body)
+      end
+
+      def remove_reaction(user_id:, post_id:, emoji_name:)
+        request(:delete, "/api/v4/reactions/#{user_id}/#{post_id}/#{emoji_name}")
+      end
+
+      # Channels
+      def create_direct_channel(user_ids)
+        request(:post, "/api/v4/channels/direct", user_ids)
+      end
+
+      def get_channel_posts(channel_id:, page: 0, per_page: 50)
+        request(:get, "/api/v4/channels/#{channel_id}/posts?page=#{page}&per_page=#{per_page}")
+      end
+
+      # Threads
+      def get_post_thread(post_id:)
+        request(:get, "/api/v4/posts/#{post_id}/thread")
+      end
+
+      # Files
+      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 = {
+          files: Faraday::Multipart::FilePart.new(io, "application/octet-stream", filename),
+          channel_id: channel_id
+        }
+
+        response = conn.post("/api/v4/files", payload) do |req|
+          req.headers["Authorization"] = "Bearer #{@bot_token}"
+        end
+
+        handle_response(response)
+      end
+
+      # Typing indicator
+      def send_typing(channel_id:)
+        request(:post, "/api/v4/users/me/typing", {"channel_id" => channel_id})
+      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"] = "Bearer #{@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.headers["Retry-After"]&.to_i
+          raise ChatSDK::RateLimitedError.new(
+            "Mattermost API rate limited",
+            retry_after: retry_after,
+            status: response.status,
+            body: response.body,
+            adapter_name: :mattermost
+          )
+        end
+
+        raise ChatSDK::PlatformError.new(
+          "Mattermost API error: #{response.status}",
+          status: response.status,
+          body: response.body,
+          adapter_name: :mattermost
+        )
+      end
+    end
+  end
+end

data/lib/chat_sdk/mattermost/attachment_renderer.rb

@@ -0,0 +1,187 @@
+# frozen_string_literal: true
+
+module ChatSDK
+  module Mattermost
+    class AttachmentRenderer
+      attr_writer :integration_url
+
+      def initialize(integration_url: nil)
+        @integration_url = integration_url
+      end
+
+      def render(node)
+        case node.type
+        when :card then render_card(node)
+        else wrap_attachment(render_node(node))
+        end
+      end
+
+      private
+
+      def render_card(node)
+        attachment = {}
+        fields = []
+        actions = []
+        text_parts = []
+
+        node.children.each do |child|
+          case child.type
+          when :text
+            text_parts << child.attributes[:content]
+          when :divider
+            text_parts << "---"
+          when :image
+            attachment["image_url"] = child.attributes[:url]
+          when :fields
+            child.children.each do |field|
+              fields << {
+                "title" => field.attributes[:label],
+                "value" => field.attributes[:value],
+                "short" => true
+              }
+            end
+          when :section
+            render_section_into(child, text_parts, fields, actions)
+          when :actions
+            child.children.each do |action_node|
+              action = render_action(action_node)
+              actions << action if action
+            end
+          when :button
+            action = render_action(child)
+            actions << action if action
+          when :select
+            action = render_action(child)
+            actions << action if action
+          end
+        end
+
+        attachment["text"] = text_parts.join("\n") unless text_parts.empty?
+        attachment["fields"] = fields unless fields.empty?
+        attachment["actions"] = actions unless actions.empty?
+
+        if node.attributes[:title]
+          attachment["title"] = node.attributes[:title]
+        end
+
+        [attachment]
+      end
+
+      def render_section_into(node, text_parts, fields, actions)
+        text_parts << "**#{node.attributes[:title]}**" if node.attributes[:title]
+
+        node.children.each do |child|
+          case child.type
+          when :text
+            text_parts << child.attributes[:content]
+          when :fields
+            child.children.each do |field|
+              fields << {
+                "title" => field.attributes[:label],
+                "value" => field.attributes[:value],
+                "short" => true
+              }
+            end
+          when :actions
+            child.children.each do |action_node|
+              action = render_action(action_node)
+              actions << action if action
+            end
+          when :button, :select
+            action = render_action(child)
+            actions << action if action
+          end
+        end
+      end
+
+      def render_action(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)
+        action = {
+          "id" => node.attributes[:id] || "button",
+          "name" => node.attributes[:text],
+          "type" => "button"
+        }
+
+        if @integration_url
+          action["integration"] = {
+            "url" => @integration_url,
+            "context" => {
+              "action" => node.attributes[:id],
+              "value" => node.attributes[:value]
+            }.compact
+          }
+        end
+
+        if node.attributes[:style] == :primary
+          action["style"] = "primary"
+        elsif node.attributes[:style] == :danger
+          action["style"] = "danger"
+        end
+
+        action
+      end
+
+      def render_link_button(node)
+        # Mattermost does not have native link buttons in attachments.
+        # Render as a button with a URL in the integration context.
+        {
+          "id" => node.attributes[:id] || "link",
+          "name" => node.attributes[:text],
+          "type" => "button",
+          "integration" => {
+            "url" => node.attributes[:url],
+            "context" => {"action" => "open_url", "url" => node.attributes[:url]}
+          }
+        }
+      end
+
+      def render_select(node)
+        action = {
+          "id" => node.attributes[:id] || "select",
+          "name" => node.attributes[:placeholder] || "Select",
+          "type" => "select",
+          "options" => node.children.map do |opt|
+            {"text" => opt.attributes[:text], "value" => opt.attributes[:value]}
+          end
+        }
+
+        if @integration_url
+          action["integration"] = {
+            "url" => @integration_url,
+            "context" => {"action" => node.attributes[:id]}
+          }
+        end
+
+        action
+      end
+
+      def render_node(node)
+        case node.type
+        when :text
+          {"text" => node.attributes[:content]}
+        when :fields
+          fields = node.children.map do |field|
+            {"title" => field.attributes[:label], "value" => field.attributes[:value], "short" => true}
+          end
+          {"fields" => fields}
+        when :actions
+          actions = node.children.filter_map { |child| render_action(child) }
+          {"actions" => actions}
+        else
+          {"text" => node.fallback_text}
+        end
+      end
+
+      def wrap_attachment(content)
+        [content]
+      end
+    end
+  end
+end

data/lib/chat_sdk/mattermost/event_parser.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+module ChatSDK
+  module Mattermost
+    class EventParser
+      class << self
+        def parse(payload, bot_user_id: nil)
+          return [] unless payload.is_a?(Hash)
+
+          if payload.key?("trigger_word") || payload.key?("token")
+            parse_outgoing_webhook(payload, bot_user_id)
+          elsif payload.key?("context") && (payload.key?("type") || payload.key?("action"))
+            parse_interactive_action(payload)
+          else
+            []
+          end
+        end
+
+        private
+
+        def parse_outgoing_webhook(payload, bot_user_id)
+          return [] if bot_user_id && payload["user_id"] == bot_user_id
+
+          author = ChatSDK::Author.new(
+            id: payload["user_id"] || "unknown",
+            name: payload["user_name"] || payload["user_id"] || "unknown",
+            platform: :mattermost,
+            bot: false
+          )
+
+          channel_id = payload["channel_id"]
+          thread_id = payload["root_id"].to_s.empty? ? nil : payload["root_id"]
+
+          message = ChatSDK::Message.new(
+            id: payload["post_id"] || "unknown",
+            text: payload["text"] || "",
+            author: author,
+            thread_id: thread_id || payload["post_id"],
+            channel_id: channel_id,
+            platform: :mattermost,
+            raw: payload
+          )
+
+          if payload["trigger_word"].to_s.start_with?("@")
+            [ChatSDK::Events::Mention.new(
+              message: message,
+              thread_id: thread_id || payload["post_id"],
+              channel_id: channel_id,
+              platform: :mattermost,
+              adapter_name: :mattermost,
+              raw: payload
+            )]
+          else
+            [ChatSDK::Events::SubscribedMessage.new(
+              message: message,
+              thread_id: thread_id || payload["post_id"],
+              channel_id: channel_id,
+              platform: :mattermost,
+              adapter_name: :mattermost,
+              raw: payload
+            )]
+          end
+        end
+
+        def parse_interactive_action(payload)
+          user = ChatSDK::Author.new(
+            id: payload["user_id"] || "unknown",
+            name: payload["user_name"] || payload["user_id"] || "unknown",
+            platform: :mattermost,
+            bot: false
+          )
+
+          channel_id = payload["channel_id"]
+          context = payload["context"] || {}
+          action_id = context["action"] || payload["action"] || "unknown"
+
+          value = if payload["type"] == "select"
+            payload["selected_option"]
+          else
+            context["value"]
+          end
+          value = value.is_a?(Hash) ? JSON.generate(value) : value.to_s
+
+          [ChatSDK::Events::Action.new(
+            action_id: action_id,
+            value: value,
+            user: user,
+            thread_id: payload["post_id"],
+            channel_id: channel_id,
+            platform: :mattermost,
+            adapter_name: :mattermost,
+            raw: payload
+          )]
+        end
+      end
+    end
+  end
+end

data/lib/chat_sdk/mattermost.rb

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

metadata

@@ -0,0 +1,74 @@
+--- !ruby/object:Gem::Specification
+name: chat_sdk-mattermost
+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: 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: Mattermost bot adapter for the ChatSDK framework
+email:
+- eng@rootly.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/chat_sdk/mattermost.rb
+- lib/chat_sdk/mattermost/adapter.rb
+- lib/chat_sdk/mattermost/api_client.rb
+- lib/chat_sdk/mattermost/attachment_renderer.rb
+- lib/chat_sdk/mattermost/event_parser.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: Mattermost adapter for ChatSDK
+test_files: []