chat_sdk-gitlab 1.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 503a31094f4c8d541f4b41741fa3efb0549f109146cef596a8cc7770ff3fd8a8
+  data.tar.gz: f81ae7bad3b61a5ee2ff20c2db6706744b251c77adf309de9e95ad39ce5e5e09
+SHA512:
+  metadata.gz: 63773ba0ffa5d0ad839bfe36f1d8abcca72d7ef971e9d567342e4859a7e9b3d49d9e3a58ef4a08f302421596d594008002cfcbc6c0aafd63053a8159afbf0c6e
+  data.tar.gz: 46f68e8c3cb56ace4b9caf362aaa555bf95d0ba54622d740c0c258f0491f39b31c0da5e1f44d5697de443ee4f5e669032fd9416241c07b8b57a7ac0e5f2f9d9b

data/lib/chat_sdk/gitlab/adapter.rb

@@ -0,0 +1,408 @@
+# frozen_string_literal: true
+
+require "base64"
+require "digest"
+require "openssl"
+require "rack/utils"
+
+module ChatSDK
+  module GitLab
+    class Adapter < ChatSDK::Adapter::Base
+      capabilities :edit_messages, :delete_messages, :reactions, :typing_indicator, :message_history
+
+      DEFAULT_API_URL = "https://gitlab.com/api/v4"
+      DEFAULT_BOT_USERNAME = "gitlab-bot"
+      MAX_PER_PAGE = 100
+      SIGNATURE_TOLERANCE = 5 * 60
+      THREAD_ID_PATTERN = /\Agitlab:(\d+):(mr|issue):(\d+)(?::([0-9a-f]+))?\z/
+      CHANNEL_ID_PATTERN = /\Agitlab:(\d+)\z/
+      NOTE_ID_PATTERN = /\A\d+\z/
+      PAGE_PATTERN = /\A[1-9]\d*\z/
+      SIGNING_TOKEN_PATTERN = /\A(?:whsec_)?([A-Za-z0-9+\/]{43}=)\z/
+      GITLAB_EMOJI_NAMES = {
+        "thumbs_up" => "thumbsup",
+        "thumbs_down" => "thumbsdown",
+        "facepalm" => "face_palm",
+        "thinking" => "thinking",
+        "hug" => "hugging",
+        "medal" => "first_place",
+        "memo" => "pencil",
+        "email" => "e-mail",
+        "rain" => "cloud_rain"
+      }.freeze
+      NORMALIZED_EMOJI_NAMES = GITLAB_EMOJI_NAMES.invert.freeze
+
+      attr_reader :client, :bot_user_id, :bot_username
+
+      def initialize(token: nil, webhook_signing_token: nil, webhook_secret: nil,
+        api_url: nil, bot_user_id: nil, bot_username: nil)
+        @token = token || ENV["GITLAB_TOKEN"]
+        @webhook_signing_token = webhook_signing_token || ENV["GITLAB_WEBHOOK_SIGNING_TOKEN"]
+        @webhook_secret = webhook_secret || ENV["GITLAB_WEBHOOK_SECRET"]
+        @api_url = api_url || ENV["GITLAB_API_URL"] || DEFAULT_API_URL
+        @bot_user_id = bot_user_id || ENV["GITLAB_BOT_USER_ID"]
+        configured_username = bot_username || ENV["GITLAB_BOT_USERNAME"]
+        @explicit_bot_username = !configured_username.nil? && !configured_username.empty?
+        @bot_username = configured_username || DEFAULT_BOT_USERNAME
+
+        raise ChatSDK::ConfigurationError, "GitLab token required; set GITLAB_TOKEN" if blank?(@token)
+        if blank?(@webhook_signing_token) && blank?(@webhook_secret)
+          raise ChatSDK::ConfigurationError,
+            "GitLab webhook verification required; set GITLAB_WEBHOOK_SIGNING_TOKEN or GITLAB_WEBHOOK_SECRET"
+        end
+
+        @bot_user_id = @bot_user_id.to_s unless blank?(@bot_user_id)
+        @identity_resolved = @bot_user_id && @explicit_bot_username
+        @signing_key = decode_signing_token(@webhook_signing_token) unless blank?(@webhook_signing_token)
+        @client = ApiClient.new(token: @token, api_url: @api_url)
+        @format_converter = FormatConverter.new
+        @card_renderer = CardRenderer.new
+      end
+
+      def name
+        :gitlab
+      end
+
+      def verify_request!(rack_request)
+        body = rack_request.body.read
+        rack_request.body.rewind
+        signature = rack_request.get_header("HTTP_WEBHOOK_SIGNATURE")
+
+        if @signing_key && signature
+          return true if verify_signature(
+            body,
+            rack_request.get_header("HTTP_WEBHOOK_ID"),
+            rack_request.get_header("HTTP_WEBHOOK_TIMESTAMP"),
+            signature
+          )
+
+          raise ChatSDK::SignatureVerificationError, "Invalid GitLab webhook signature"
+        end
+
+        token = rack_request.get_header("HTTP_X_GITLAB_TOKEN")
+        if @webhook_secret && token && secure_token_match?(@webhook_secret, token)
+          return true
+        end
+
+        raise ChatSDK::SignatureVerificationError, "Invalid GitLab webhook token or signature"
+      end
+
+      def ack_response(_rack_request)
+        nil
+      end
+
+      def parse_events(rack_request)
+        payload = read_json_body(rack_request)
+        return [] unless payload.is_a?(Hash)
+
+        event_type = rack_request.get_header("HTTP_X_GITLAB_EVENT")
+        expected_kind = {"Note Hook" => "note", "Emoji Hook" => "emoji"}[event_type]
+        return [] unless expected_kind && payload["object_kind"] == expected_kind
+        return [] unless resolve_bot_identity
+
+        EventParser.new(
+          bot_user_id: @bot_user_id,
+          bot_username: @bot_username,
+          explicit_bot_username: @explicit_bot_username
+        ).parse(payload, event_type: event_type)
+      rescue JSON::ParserError
+        []
+      end
+
+      def encode_thread_id(project_id:, noteable_type:, noteable_iid:, discussion_id: nil)
+        project = project_id.to_s
+        iid = noteable_iid.to_s
+        kind = case noteable_type.to_s
+        when "mr", "merge_request", "MergeRequest" then "mr"
+        when "issue", "Issue" then "issue"
+        else raise ArgumentError, "Invalid GitLab noteable type: #{noteable_type}"
+        end
+        unless project.match?(/\A\d+\z/) && iid.match?(/\A\d+\z/)
+          raise ArgumentError, "GitLab project and noteable IDs must be numeric"
+        end
+        if discussion_id && !discussion_id.to_s.match?(/\A[0-9a-f]+\z/)
+          raise ArgumentError, "Invalid GitLab discussion ID: #{discussion_id}"
+        end
+
+        id = "gitlab:#{project}:#{kind}:#{iid}"
+        discussion_id ? "#{id}:#{discussion_id}" : id
+      end
+
+      def decode_thread_id(thread_id)
+        match = THREAD_ID_PATTERN.match(thread_id.to_s)
+        raise ArgumentError, "Invalid GitLab thread ID: #{thread_id}" unless match
+
+        {
+          project_id: match[1].to_i,
+          noteable_type: match[2] == "mr" ? :merge_request : :issue,
+          noteable_iid: match[3].to_i,
+          discussion_id: match[4]
+        }
+      end
+
+      def channel_id_from_thread_id(thread_id)
+        "gitlab:#{decode_thread_id(thread_id)[:project_id]}"
+      end
+
+      def post_message(channel_id:, message:, thread_id: nil)
+        thread = validated_thread!(channel_id, thread_id)
+        note = @client.request_api(
+          :post,
+          note_collection_path(thread),
+          body: {"body" => render(message)}
+        )
+        @bot_user_id ||= note.dig("author", "id").to_s if note.dig("author", "id")
+        build_message(note, thread, channel_id, thread_id)
+      end
+
+      def edit_message(channel_id:, message_id:, message:, thread_id: nil)
+        thread = validated_thread!(channel_id, thread_id)
+        validate_message_id!(message_id)
+        validate_discussion_note!(thread, message_id)
+        note = @client.request_api(
+          :put,
+          "#{noteable_path(thread)}/notes/#{message_id}",
+          body: {"body" => render(message)}
+        )
+        build_message(note, thread, channel_id, thread_id)
+      end
+
+      def delete_message(channel_id:, message_id:, thread_id: nil)
+        thread = validated_thread!(channel_id, thread_id)
+        validate_message_id!(message_id)
+        validate_discussion_note!(thread, message_id)
+        @client.request_api(:delete, "#{noteable_path(thread)}/notes/#{message_id}")
+      end
+
+      def add_reaction(channel_id:, message_id:, emoji:, thread_id: nil)
+        thread = validated_thread!(channel_id, thread_id)
+        validate_message_id!(message_id)
+        validate_discussion_note!(thread, message_id)
+        award_path = "#{noteable_path(thread)}/notes/#{message_id}/award_emoji"
+        name = to_gitlab_emoji(emoji)
+
+        begin
+          @client.request_api(:post, award_path, body: {"name" => name})
+        rescue ChatSDK::PlatformError => error
+          raise unless error.status == 404 && @bot_user_id
+          raise unless @client.request_all(award_path).any? do |award|
+            award["name"] == name && award.dig("user", "id").to_s == @bot_user_id
+          end
+        end
+      end
+
+      def remove_reaction(channel_id:, message_id:, emoji:, thread_id: nil)
+        thread = validated_thread!(channel_id, thread_id)
+        validate_message_id!(message_id)
+        validate_discussion_note!(thread, message_id)
+        resolve_bot_identity unless @bot_user_id
+        raise ChatSDK::ConfigurationError, "GitLab bot user ID is required to remove reactions" unless @bot_user_id
+
+        award_path = "#{noteable_path(thread)}/notes/#{message_id}/award_emoji"
+        award = @client.request_all(award_path).find do |item|
+          item["name"] == to_gitlab_emoji(emoji) &&
+            item.dig("user", "id").to_s == @bot_user_id
+        end
+        return unless award && NOTE_ID_PATTERN.match?(award["id"].to_s)
+
+        @client.request_api(:delete, "#{award_path}/#{award["id"]}")
+      end
+
+      def fetch_messages(channel_id:, thread_id: nil, cursor: nil, limit: 50)
+        thread = validated_thread!(channel_id, thread_id)
+        per_page = [[limit.to_i, 1].max, MAX_PER_PAGE].min
+
+        if thread[:discussion_id]
+          discussion = @client.request_api(
+            :get,
+            "#{noteable_path(thread)}/discussions/#{thread[:discussion_id]}"
+          )
+          notes = Array(discussion["notes"]).reject { |note| internal_note?(note) }
+          notes.sort_by! { |note| parse_timestamp(note["created_at"]) || Time.at(0) }
+          messages = notes.map { |note| build_message(note, thread, channel_id, thread_id) }
+          return [messages.last(per_page), nil]
+        end
+
+        page = PAGE_PATTERN.match?(cursor.to_s) ? cursor.to_s : "1"
+        notes, next_page = @client.request_page(
+          "#{noteable_path(thread)}/notes",
+          query: {
+            order_by: "created_at",
+            sort: "desc",
+            per_page: per_page,
+            page: page
+          }
+        )
+        notes = notes.is_a?(Array) ? notes.reverse : []
+        messages = notes.reject { |note| internal_note?(note) }
+          .map { |note| build_message(note, thread, channel_id, thread_id) }
+        [messages, next_page.to_s.empty? ? nil : next_page]
+      end
+
+      def start_typing(channel_id:, thread_id: nil, message_id: nil)
+        validated_thread!(channel_id, thread_id)
+        nil
+      end
+
+      def mention(user)
+        "@#{user.to_s.sub(/\A@/, "")}"
+      end
+
+      def render(postable_message)
+        message = ChatSDK::PostableMessage.from(postable_message)
+        return @card_renderer.render(message.card) if message.card?
+
+        @format_converter.from_markdown(message.text)
+      end
+
+      private
+
+      def resolve_bot_identity
+        return true if @identity_resolved
+
+        user = @client.current_user
+        @bot_user_id ||= user["id"].to_s if user["id"]
+        if !@explicit_bot_username && user["username"]
+          @bot_username = user["username"]
+        end
+        @identity_resolved = !blank?(@bot_user_id) &&
+          (@explicit_bot_username || !blank?(user["username"]))
+        @bot_user_id || @explicit_bot_username
+      rescue ChatSDK::PlatformError, Faraday::Error
+        @bot_user_id || @explicit_bot_username
+      end
+
+      def verify_signature(body, message_id, timestamp, signature)
+        return false if blank?(message_id) || blank?(timestamp)
+        return false unless timestamp.to_s.match?(/\A\d+\z/)
+        return false if (Time.now.to_i - timestamp.to_i).abs > SIGNATURE_TOLERANCE
+
+        digest = OpenSSL::HMAC.digest("SHA256", @signing_key, "#{message_id}.#{timestamp}.#{body}")
+        expected = "v1,#{Base64.strict_encode64(digest)}"
+        signature.split(/\s+/).any? do |candidate|
+          candidate.start_with?("v1,") &&
+            candidate.bytesize == expected.bytesize &&
+            Rack::Utils.secure_compare(candidate, expected)
+        end
+      end
+
+      def secure_token_match?(expected, received)
+        expected_digest = Digest::SHA256.hexdigest(expected)
+        received_digest = Digest::SHA256.hexdigest(received)
+        Rack::Utils.secure_compare(expected_digest, received_digest)
+      end
+
+      def decode_signing_token(token)
+        match = SIGNING_TOKEN_PATTERN.match(token.to_s)
+        raise ChatSDK::ConfigurationError, "Invalid GitLab webhook signing token" unless match
+
+        Base64.strict_decode64(match[1])
+      rescue ArgumentError
+        raise ChatSDK::ConfigurationError, "Invalid GitLab webhook signing token"
+      end
+
+      def validated_thread!(channel_id, thread_id)
+        thread = decode_thread_id(thread_id)
+        channel_project = decode_channel_id(channel_id)
+        unless channel_project == thread[:project_id]
+          raise ArgumentError, "GitLab thread #{thread_id} does not belong to channel #{channel_id}"
+        end
+
+        thread
+      end
+
+      def decode_channel_id(channel_id)
+        match = CHANNEL_ID_PATTERN.match(channel_id.to_s)
+        raise ArgumentError, "Invalid GitLab channel ID: #{channel_id}" unless match
+
+        match[1].to_i
+      end
+
+      def validate_message_id!(message_id)
+        raise ArgumentError, "Invalid GitLab note ID: #{message_id}" unless NOTE_ID_PATTERN.match?(message_id.to_s)
+      end
+
+      def validate_discussion_note!(thread, message_id)
+        discussion_id = thread[:discussion_id]
+        return unless discussion_id
+
+        discussion = @client.request_api(
+          :get,
+          "#{noteable_path(thread)}/discussions/#{discussion_id}"
+        )
+        return if Array(discussion["notes"]).any? { |note| note["id"].to_s == message_id.to_s }
+
+        raise ArgumentError, "GitLab note #{message_id} does not belong to discussion #{discussion_id}"
+      end
+
+      def noteable_path(thread)
+        collection = thread[:noteable_type] == :merge_request ? "merge_requests" : "issues"
+        "/projects/#{thread[:project_id]}/#{collection}/#{thread[:noteable_iid]}"
+      end
+
+      def note_collection_path(thread)
+        base = noteable_path(thread)
+        discussion_id = thread[:discussion_id]
+        discussion_id ? "#{base}/discussions/#{discussion_id}/notes" : "#{base}/notes"
+      end
+
+      def build_message(note, thread, channel_id, thread_id)
+        author = note["author"].is_a?(Hash) ? note["author"] : {}
+        author_id = author["id"] || "bot"
+        author_name = author["name"] || author["username"] || "GitLab bot"
+        author_username = author["username"].to_s
+        text = @format_converter.to_markdown(note["body"] || "")
+        ChatSDK::Message.new(
+          id: note["id"].to_s,
+          text: text,
+          author: ChatSDK::Author.new(
+            id: author_id.to_s,
+            name: author_name,
+            platform: :gitlab,
+            bot: author["bot"] == true ||
+              EventParser::PROJECT_BOT_USERNAME.match?(author_username) ||
+              (@bot_user_id && author_id.to_s == @bot_user_id) ||
+              author_username.casecmp?(@bot_username)
+          ),
+          thread_id: thread_id,
+          channel_id: channel_id,
+          platform: :gitlab,
+          raw: {
+            note: note,
+            project_id: thread[:project_id],
+            noteable_type: thread[:noteable_type],
+            noteable_iid: thread[:noteable_iid],
+            discussion_id: thread[:discussion_id]
+          },
+          timestamp: parse_timestamp(note["created_at"]),
+          is_mention: mention_in?(text)
+        )
+      end
+
+      def mention_in?(text)
+        masked = ChatSDK::Format::Mentions.mask_code_spans(text)
+        username = Regexp.escape(@bot_username.to_s.sub(/\A@/, ""))
+        masked.match?(/(?<!\w)@#{username}(?![\w-])/i)
+      end
+
+      def internal_note?(note)
+        note["system"] == true || note["internal"] == true || note["confidential"] == true
+      end
+
+      def parse_timestamp(value)
+        Time.parse(value) if value
+      rescue ArgumentError
+        nil
+      end
+
+      def to_gitlab_emoji(emoji)
+        name = emoji.respond_to?(:name) ? emoji.name.to_s : emoji.to_s
+        GITLAB_EMOJI_NAMES.fetch(name, name)
+      end
+
+      def blank?(value)
+        value.nil? || value.to_s.empty?
+      end
+    end
+  end
+end

data/lib/chat_sdk/gitlab/api_client.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+require "uri"
+
+module ChatSDK
+  module GitLab
+    class ApiClient < ChatSDK::ApiClient::Base
+      MAX_PAGES = 20
+      PER_PAGE = 100
+
+      def initialize(token:, api_url:)
+        @token = token
+        @api_url = api_url.sub(%r{/+\z}, "")
+      end
+
+      def current_user
+        request(:get, "/user")
+      end
+
+      def request_api(method, path, body: nil, query: nil)
+        query_string = URI.encode_www_form(query || {})
+        request(method.to_sym, query_string.empty? ? path : "#{path}?#{query_string}", body)
+      end
+
+      def request_page(path, query:)
+        response = connection.get(resolve_path(path)) do |req|
+          req.params.update(query)
+        end
+        handle_response(response)
+        [response.body, response.headers["x-next-page"]]
+      end
+
+      def request_all(path, query: {})
+        results = []
+        page = "1"
+
+        MAX_PAGES.times do
+          values, next_page = request_page(path, query: query.merge(per_page: PER_PAGE, page: page))
+          results.concat(values) if values.is_a?(Array)
+          break if next_page.nil? || next_page.empty?
+
+          page = next_page
+        end
+
+        results
+      end
+
+      private
+
+      def base_url
+        "#{@api_url}/"
+      end
+
+      def resolve_path(path)
+        path.sub(/\A\//, "")
+      end
+
+      def adapter_name
+        :gitlab
+      end
+
+      def configure_auth(faraday)
+        faraday.headers["Authorization"] = "Bearer #{@token}"
+      end
+
+      def extract_retry_after(response)
+        value = response.headers["retry-after"]
+        value.to_i if value
+      end
+
+      def extract_error_message(response)
+        body = response.body
+        return response.status.to_s unless body.is_a?(Hash)
+
+        message = body["message"]
+        return message if message.is_a?(String)
+        if message.is_a?(Hash)
+          return message.map do |field, errors|
+            "#{field} #{Array(errors).join(", ")}"
+          end.join("; ")
+        end
+
+        body["error"] || response.status.to_s
+      end
+    end
+  end
+end

data/lib/chat_sdk/gitlab/card_renderer.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+module ChatSDK
+  module GitLab
+    class CardRenderer
+      MARKDOWN_ESCAPED = ["\\", "*", "_", "[", "]"].freeze
+      URL_UNSAFE = /[\s()<>]/
+
+      def render(card)
+        lines = []
+        title = card.attributes[:title]
+        subtitle = card.attributes[:subtitle]
+        lines << "**#{escape_markdown(title)}**" if title
+        lines << escape_markdown(subtitle) if subtitle
+        lines << "" if (title || subtitle) && card.children.any?
+
+        children = card.children.map { |child| render_child(child) }.reject(&:empty?)
+        children.each_with_index do |child, index|
+          lines << "" if index.positive?
+          lines << child
+        end
+        lines.join("\n")
+      end
+
+      private
+
+      def render_child(child)
+        attributes = child.attributes
+
+        case child.type
+        when :text
+          render_text(attributes[:content], attributes[:style])
+        when :field
+          "**#{escape_markdown(attributes[:label])}:** #{escape_markdown(attributes[:value])}"
+        when :fields
+          child.children.map { |field| render_child(field) }.reject(&:empty?).join("\n")
+        when :actions
+          child.children.map { |action| render_action(action) }.reject(&:empty?).join(" • ")
+        when :section
+          section = attributes[:title] ? "### #{escape_markdown(attributes[:title])}" : nil
+          ([section] + child.children.map { |nested| render_child(nested) }).compact.reject(&:empty?).join("\n")
+        when :image
+          alt = escape_markdown(attributes[:alt])
+          "![#{alt}](#{escape_url(attributes[:url])})"
+        when :divider
+          "---"
+        when :table
+          render_table(attributes)
+        else
+          child.fallback_text
+        end
+      end
+
+      def render_text(content, style)
+        case style&.to_sym
+        when :bold then "**#{content}**"
+        when :muted then "_#{content}_"
+        else content.to_s
+        end
+      end
+
+      def render_action(action)
+        attributes = action.attributes
+        label = escape_markdown(attributes[:text])
+
+        if action.type == :link_button
+          "[#{label}](#{escape_url(attributes[:url])})"
+        else
+          "**[#{label}]**"
+        end
+      end
+
+      def render_table(attributes)
+        headers = Array(attributes[:headers]).map { |value| escape_cell(value) }
+        rows = Array(attributes[:rows]).map do |row|
+          Array(row).map { |value| escape_cell(value) }
+        end
+        lines = []
+        lines << attributes[:caption].to_s if attributes[:caption]
+
+        unless headers.empty?
+          alignments = Array(attributes[:align])
+          lines << "| #{headers.join(" | ")} |"
+          lines << "| #{headers.each_index.map { |index| alignment_marker(alignments[index]) }.join(" | ")} |"
+        end
+        rows.each { |row| lines << "| #{row.join(" | ")} |" }
+        lines.join("\n")
+      end
+
+      def alignment_marker(alignment)
+        case alignment&.to_sym
+        when :center then ":---:"
+        when :right then "---:"
+        else "---"
+        end
+      end
+
+      def escape_cell(value)
+        value.to_s.gsub("|") { "\\|" }.gsub(/[\r\n]+/, " ")
+      end
+
+      def escape_markdown(value)
+        value.to_s.each_char.map do |character|
+          MARKDOWN_ESCAPED.include?(character) ? "\\#{character}" : character
+        end.join
+      end
+
+      def escape_url(value)
+        value.to_s.gsub(URL_UNSAFE) { |character| format("%%%02X", character.ord) }
+      end
+    end
+  end
+end

data/lib/chat_sdk/gitlab/event_parser.rb

@@ -0,0 +1,180 @@
+# frozen_string_literal: true
+
+require "time"
+
+module ChatSDK
+  module GitLab
+    class EventParser
+      PROJECT_BOT_USERNAME = /\A(?:project|group)_\d+_bot/
+      EMOJI_NAMES = {
+        "thumbsup" => "thumbs_up",
+        "thumbsdown" => "thumbs_down",
+        "face_palm" => "facepalm",
+        "hugging" => "hug",
+        "first_place" => "medal",
+        "pencil" => "memo",
+        "e-mail" => "email",
+        "cloud_rain" => "rain"
+      }.freeze
+
+      def initialize(bot_user_id:, bot_username:, explicit_bot_username:)
+        @bot_user_id = bot_user_id
+        @bot_username = bot_username
+        @explicit_bot_username = explicit_bot_username
+      end
+
+      def parse(payload, event_type:)
+        case event_type
+        when "Note Hook" then parse_note(payload)
+        when "Emoji Hook" then parse_emoji(payload)
+        else []
+        end
+      end
+
+      private
+
+      def parse_note(payload)
+        attributes = payload["object_attributes"]
+        return [] unless payload["object_kind"] == "note" && attributes.is_a?(Hash)
+        return [] if attributes["action"] && attributes["action"] != "create"
+        return [] if attributes["system"] || attributes["internal"] || attributes["confidential"]
+        return [] if attributes["event_type"] == "confidential_note" || payload["event_type"] == "confidential_note"
+        return [] if payload.dig("issue", "confidential")
+
+        noteable = resolve_noteable(attributes["noteable_type"], payload)
+        return [] unless noteable
+        return [] unless numeric?(attributes["id"])
+
+        author_data = payload["user"].is_a?(Hash) ? payload["user"] : {}
+        author_id = author_data["id"] || attributes["author_id"]
+        return [] if self_user?(author_id, author_data["username"])
+
+        project_id = payload["project_id"] || payload.dig("project", "id") || attributes["project_id"]
+        return [] unless numeric?(project_id) && numeric?(noteable[:iid])
+
+        thread_id = encode_thread_id(
+          project_id,
+          noteable[:type],
+          noteable[:iid],
+          attributes["discussion_id"]
+        )
+        channel_id = "gitlab:#{project_id}"
+        text = attributes["note"].to_s
+        timestamp = parse_timestamp(attributes["created_at"])
+        author = parse_author(author_data, author_id)
+        message = ChatSDK::Message.new(
+          id: attributes["id"].to_s,
+          text: text,
+          author: author,
+          thread_id: thread_id,
+          channel_id: channel_id,
+          platform: :gitlab,
+          raw: payload,
+          timestamp: timestamp,
+          is_mention: mentions_bot?(text)
+        )
+
+        [ChatSDK::Events::Mention.new(
+          message: message,
+          thread_id: thread_id,
+          channel_id: channel_id,
+          platform: :gitlab,
+          adapter_name: :gitlab,
+          raw: payload,
+          timestamp: timestamp
+        )]
+      end
+
+      def parse_emoji(payload)
+        attributes = payload["object_attributes"]
+        note = payload["note"]
+        return [] unless payload["object_kind"] == "emoji" && attributes.is_a?(Hash)
+        return [] unless attributes["awardable_type"] == "Note" && note.is_a?(Hash)
+        return [] if note["system"] || note["internal"] || note["confidential"]
+        return [] if payload.dig("issue", "confidential")
+        return [] unless %w[award revoke].include?(payload["event_type"])
+
+        noteable = resolve_noteable(note["noteable_type"], payload)
+        return [] unless noteable
+
+        user = payload["user"].is_a?(Hash) ? payload["user"] : {}
+        user_id = attributes["user_id"] || user["id"]
+        return [] if self_user?(user_id, user["username"])
+
+        project_id = payload["project_id"] || payload.dig("project", "id")
+        return [] unless numeric?(project_id) && numeric?(noteable[:iid]) && numeric?(note["id"])
+
+        thread_id = encode_thread_id(project_id, noteable[:type], noteable[:iid], note["discussion_id"])
+        channel_id = "gitlab:#{project_id}"
+        emoji_name = attributes["name"].to_s
+
+        [ChatSDK::Events::Reaction.new(
+          emoji: EMOJI_NAMES.fetch(emoji_name, emoji_name),
+          user_id: user_id.to_s,
+          message_id: note["id"].to_s,
+          thread_id: thread_id,
+          channel_id: channel_id,
+          added: payload["event_type"] == "award",
+          platform: :gitlab,
+          adapter_name: :gitlab,
+          raw: payload,
+          timestamp: parse_timestamp(attributes["created_at"])
+        )]
+      end
+
+      def resolve_noteable(type, payload)
+        case type
+        when "MergeRequest"
+          iid = payload.dig("merge_request", "iid")
+          {type: :merge_request, iid: iid} if iid
+        when "Issue"
+          iid = payload.dig("issue", "iid")
+          {type: :issue, iid: iid} if iid
+        end
+      end
+
+      def encode_thread_id(project_id, noteable_type, noteable_iid, discussion_id)
+        kind = (noteable_type == :merge_request) ? "mr" : "issue"
+        thread_id = "gitlab:#{project_id}:#{kind}:#{noteable_iid}"
+        discussion_id ? "#{thread_id}:#{discussion_id}" : thread_id
+      end
+
+      def parse_author(user, user_id)
+        username = user["username"].to_s
+        ChatSDK::Author.new(
+          id: user_id.to_s,
+          name: user["name"] || username,
+          platform: :gitlab,
+          bot: !!(
+            user["bot"] == true || PROJECT_BOT_USERNAME.match?(username) ||
+              (@bot_user_id && user_id.to_s == @bot_user_id)
+          )
+        )
+      end
+
+      def self_user?(user_id, username)
+        return user_id.to_s == @bot_user_id if @bot_user_id
+
+        @explicit_bot_username && username.to_s.casecmp?(@bot_username)
+      end
+
+      def mentions_bot?(text)
+        masked = ChatSDK::Format::Mentions.mask_code_spans(text)
+        username = Regexp.escape(@bot_username.to_s.sub(/\A@/, ""))
+        masked.match?(/(?<!\w)@#{username}(?![\w-])/i)
+      end
+
+      def numeric?(value)
+        value.to_s.match?(/\A\d+\z/)
+      end
+
+      def parse_timestamp(value)
+        return unless value
+
+        Time.parse(value)
+      rescue ArgumentError
+        nil
+      end
+    end
+  end
+end

data/lib/chat_sdk/gitlab/format_converter.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module ChatSDK
+  module GitLab
+    class FormatConverter < ChatSDK::Format::Converter
+      def to_markdown(platform_text)
+        platform_text.to_s
+      end
+
+      def from_markdown(markdown)
+        markdown.to_s
+      end
+    end
+  end
+end

data/lib/chat_sdk/gitlab.rb

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

metadata

@@ -0,0 +1,75 @@
+--- !ruby/object:Gem::Specification
+name: chat_sdk-gitlab
+version: !ruby/object:Gem::Version
+  version: 1.1.0
+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: GitLab merge request and issue comment adapter for ChatSDK
+email:
+- quentin@rootly.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/chat_sdk/gitlab.rb
+- lib/chat_sdk/gitlab/adapter.rb
+- lib/chat_sdk/gitlab/api_client.rb
+- lib/chat_sdk/gitlab/card_renderer.rb
+- lib/chat_sdk/gitlab/event_parser.rb
+- lib/chat_sdk/gitlab/format_converter.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: GitLab adapter for ChatSDK
+test_files: []