chat_sdk-gchat 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 3bfec5f052031774aa8db868e443e960182310d8af06672d7da4a9ea6e5816f8
+  data.tar.gz: 53dcace115831d3816b876f4048b3a693e72a46758c9e133dd24c37d8cad7f9d
+SHA512:
+  metadata.gz: 1930e5a33ef72f960c3368190b578c963f79e384aad21c39950657e96d2a9c8efcedba418d4b922527198668a76083af503230c0c2f09f92c03692ee40c31529
+  data.tar.gz: '08c9d6e254f0d552c94e70f2210b8304159ff02578989f14a1502e8f6fb1df4930eaceed9f891fdeb500879919022331ad69545ceb9c559f89e1d35ccc28f62d'

data/lib/chat_sdk/gchat/adapter.rb

@@ -0,0 +1,239 @@
+# frozen_string_literal: true
+
+module ChatSDK
+  module GChat
+    class Adapter < ChatSDK::Adapter::Base
+      capabilities :edit_messages, :delete_messages, :ephemeral_messages,
+        :threads, :direct_messages, :message_history,
+        :reactions, :streaming_edit
+
+      attr_reader :client
+
+      def initialize(project_number:, credentials: nil)
+        @project_number = project_number.to_s
+
+        raise ChatSDK::ConfigurationError, "Google Chat project_number required" if @project_number.empty?
+
+        @credentials = build_credentials(credentials)
+        @client = Google::Apps::Chat::V1::ChatService::Client.new do |config|
+          config.credentials = @credentials if @credentials
+        end
+        @verifier = TokenVerifier.new(@project_number)
+        @renderer = CardV2Renderer.new
+      end
+
+      def name
+        :gchat
+      end
+
+      # Inbound
+      def verify_request!(rack_request)
+        auth_header = rack_request.env["HTTP_AUTHORIZATION"] || ""
+        token = auth_header.sub(/\ABearer\s+/i, "")
+        @verifier.verify!(token)
+        true
+      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)
+        request_body = build_message_body(msg)
+
+        if thread_id
+          request_body[:thread] = {name: "spaces/#{channel_id}/threads/#{thread_id}"}
+        end
+
+        result = @client.create_message(
+          parent: "spaces/#{channel_id}",
+          message: request_body
+        )
+
+        build_response_message(result, channel_id, msg)
+      end
+
+      def edit_message(channel_id:, message_id:, message:)
+        require_capability!(:edit_messages)
+        msg = ChatSDK::PostableMessage.from(message)
+        request_body = build_message_body(msg)
+        request_body[:name] = "spaces/#{channel_id}/messages/#{message_id}"
+
+        @client.update_message(
+          message: request_body,
+          update_mask: Google::Protobuf::FieldMask.new(paths: ["text", "cards_v2"])
+        )
+      end
+
+      def delete_message(channel_id:, message_id:)
+        require_capability!(:delete_messages)
+        @client.delete_message(name: "spaces/#{channel_id}/messages/#{message_id}")
+      end
+
+      def post_ephemeral(channel_id:, user_id:, message:, thread_id: nil)
+        require_capability!(:ephemeral_messages)
+        msg = ChatSDK::PostableMessage.from(message)
+        request_body = build_message_body(msg)
+        request_body[:private_message_viewer] = {name: "users/#{user_id}"}
+
+        if thread_id
+          request_body[:thread] = {name: "spaces/#{channel_id}/threads/#{thread_id}"}
+        end
+
+        result = @client.create_message(
+          parent: "spaces/#{channel_id}",
+          message: request_body
+        )
+
+        build_response_message(result, channel_id, msg)
+      end
+
+      def upload_file(channel_id:, io:, filename:, thread_id: nil, comment: nil)
+        super
+      end
+
+      def add_reaction(channel_id:, message_id:, emoji:)
+        require_capability!(:reactions)
+        @client.create_reaction(
+          parent: "spaces/#{channel_id}/messages/#{message_id}",
+          reaction: {
+            emoji: {unicode: emoji}
+          }
+        )
+      end
+
+      def remove_reaction(channel_id:, message_id:, emoji:)
+        require_capability!(:reactions)
+        # Google Chat requires the reaction resource name to delete
+        # We construct it from the emoji unicode
+        @client.delete_reaction(
+          name: "spaces/#{channel_id}/messages/#{message_id}/reactions/#{emoji}"
+        )
+      end
+
+      def open_dm(user_id)
+        require_capability!(:direct_messages)
+        result = @client.setup_space(
+          space: {space_type: "DIRECT_MESSAGE"},
+          memberships: [{member: {name: "users/#{user_id}", type: "HUMAN"}}]
+        )
+        extract_id(result.name)
+      end
+
+      def fetch_messages(channel_id:, thread_id: nil, cursor: nil, limit: 50)
+        require_capability!(:message_history)
+        result = @client.list_messages(
+          parent: "spaces/#{channel_id}",
+          page_size: limit,
+          page_token: cursor
+        )
+
+        messages = result.messages.map { |m| parse_gchat_message(m, channel_id) }
+        [messages, result.next_page_token.to_s.empty? ? nil : result.next_page_token]
+      end
+
+      def open_modal(trigger_id:, modal:)
+        super
+      end
+
+      def start_typing(channel_id:, thread_id: nil)
+        super
+      end
+
+      def mention(user_id)
+        "<users/#{user_id}>"
+      end
+
+      def render(postable_message)
+        if postable_message.card?
+          @renderer.render(postable_message.card)
+        else
+          postable_message.text
+        end
+      end
+
+      private
+
+      def build_credentials(credentials)
+        case credentials
+        when nil
+          # Use Application Default Credentials
+          Google::Auth.get_application_default(
+            ["https://www.googleapis.com/auth/chat.bot"]
+          )
+        when String
+          # Path to service account JSON
+          Google::Auth::ServiceAccountCredentials.make_creds(
+            json_key_io: File.open(credentials),
+            scope: "https://www.googleapis.com/auth/chat.bot"
+          )
+        when Hash
+          # Service account JSON as a hash
+          Google::Auth::ServiceAccountCredentials.make_creds(
+            json_key_io: StringIO.new(JSON.generate(credentials)),
+            scope: "https://www.googleapis.com/auth/chat.bot"
+          )
+        else
+          credentials
+        end
+      end
+
+      def build_message_body(msg)
+        body = {}
+
+        if msg.card?
+          rendered = @renderer.render(msg.card)
+          body[:cards_v2] = rendered[:cards_v2] if rendered[:cards_v2]
+          body[:text] = msg.text || msg.card.fallback_text
+        else
+          body[:text] = msg.text
+        end
+
+        body
+      end
+
+      def build_response_message(result, channel_id, msg)
+        ChatSDK::Message.new(
+          id: extract_id(result.name),
+          text: msg.text || "",
+          author: ChatSDK::Author.new(id: "bot", name: "bot", platform: :gchat, bot: true),
+          thread_id: extract_id(result.thread&.name),
+          channel_id: channel_id,
+          platform: :gchat,
+          raw: result
+        )
+      end
+
+      def parse_gchat_message(msg, channel_id)
+        sender = msg.sender
+        ChatSDK::Message.new(
+          id: extract_id(msg.name),
+          text: msg.text || "",
+          author: ChatSDK::Author.new(
+            id: extract_id(sender&.name || "unknown"),
+            name: sender&.display_name || "unknown",
+            platform: :gchat,
+            bot: sender&.type == :BOT
+          ),
+          thread_id: extract_id(msg.thread&.name),
+          channel_id: channel_id,
+          platform: :gchat,
+          raw: msg
+        )
+      end
+
+      def extract_id(resource_name)
+        return resource_name unless resource_name.is_a?(String)
+        resource_name.split("/").last || resource_name
+      end
+    end
+  end
+end

data/lib/chat_sdk/gchat/card_v2_renderer.rb

@@ -0,0 +1,188 @@
+# frozen_string_literal: true
+
+module ChatSDK
+  module GChat
+    class CardV2Renderer
+      def render(node)
+        case node.type
+        when :card then render_card(node)
+        else {cards_v2: [{card: {sections: [{widgets: [render_widget(node)]}]}}]}
+        end
+      end
+
+      private
+
+      def render_card(node)
+        header = build_header(node)
+        sections = build_sections(node.children)
+
+        card = {}
+        card[:header] = header if header
+        card[:sections] = sections unless sections.empty?
+
+        {cards_v2: [{card: card}]}
+      end
+
+      def build_header(node)
+        return nil unless node.attributes[:title]
+
+        header = {title: node.attributes[:title]}
+        header[:subtitle] = node.attributes[:subtitle] if node.attributes[:subtitle]
+        header
+      end
+
+      def build_sections(children)
+        sections = []
+        current_widgets = []
+
+        children.each do |child|
+          case child.type
+          when :divider
+            sections << {widgets: current_widgets} unless current_widgets.empty?
+            current_widgets = []
+            sections << {widgets: [{divider: {}}]}
+          when :section
+            sections << {widgets: current_widgets} unless current_widgets.empty?
+            current_widgets = []
+            section = {}
+            section[:header] = child.attributes[:title] if child.attributes[:title]
+            section[:widgets] = child.children.flat_map { |c| render_widgets(c) }.compact
+            sections << section
+          else
+            render_widgets(child).each { |w| current_widgets << w }
+          end
+        end
+
+        sections << {widgets: current_widgets} unless current_widgets.empty?
+        sections
+      end
+
+      def render_widget(node)
+        case node.type
+        when :text then render_text(node)
+        when :fields then render_fields(node)
+        when :image then render_image(node)
+        when :actions then render_actions(node)
+        when :divider then {divider: {}}
+        when :select then render_select(node)
+        end
+      end
+
+      def render_widgets(node)
+        case node.type
+        when :actions then render_actions_as_widgets(node)
+        else
+          widget = render_widget(node)
+          widget ? [widget] : []
+        end
+      end
+
+      def render_text(node)
+        {textParagraph: {text: node.attributes[:content]}}
+      end
+
+      def render_fields(node)
+        {
+          decoratedText: {
+            topLabel: node.children.map { |f| f.attributes[:label] }.join(" | "),
+            text: node.children.map { |f| f.attributes[:value] }.join(" | ")
+          }
+        }
+      end
+
+      def render_image(node)
+        img = {imageUrl: node.attributes[:url]}
+        img[:altText] = node.attributes[:alt] if node.attributes[:alt]
+        {image: img}
+      end
+
+      def render_actions(node)
+        widgets = render_actions_as_widgets(node)
+        # For single-widget render path, return the first widget (buttonList or select)
+        widgets.first
+      end
+
+      def render_actions_as_widgets(node)
+        widgets = []
+        buttons = []
+        node.children.each do |child|
+          if child.type == :select
+            widgets << render_button_list(buttons) unless buttons.empty?
+            buttons = []
+            widgets << render_select(child)
+          else
+            btn = render_action_element(child)
+            buttons << btn if btn
+          end
+        end
+        widgets << render_button_list(buttons) unless buttons.empty?
+        widgets
+      end
+
+      def render_button_list(buttons)
+        {buttonList: {buttons: buttons}}
+      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 nil # selects are rendered as their own widget
+        end
+      end
+
+      def render_button(node)
+        btn = {
+          text: node.attributes[:text],
+          onClick: {
+            action: {
+              actionMethodName: node.attributes[:id]
+            }
+          }
+        }
+
+        if node.attributes[:value]
+          btn[:onClick][:action][:parameters] = [
+            {key: "value", value: node.attributes[:value]}
+          ]
+        end
+
+        if node.attributes[:style] == :primary
+          btn[:color] = {red: 0.0, green: 0.53, blue: 0.87, alpha: 1.0}
+        elsif node.attributes[:style] == :danger
+          btn[:color] = {red: 0.87, green: 0.17, blue: 0.17, alpha: 1.0}
+        end
+
+        btn
+      end
+
+      def render_link_button(node)
+        {
+          text: node.attributes[:text],
+          onClick: {
+            openLink: {url: node.attributes[:url]}
+          }
+        }
+      end
+
+      def render_select(node)
+        {
+          selectionInput: {
+            name: node.attributes[:id],
+            label: node.attributes[:placeholder] || "Select",
+            type: "DROPDOWN",
+            items: node.children.map { |opt| render_select_option(opt) }
+          }
+        }
+      end
+
+      def render_select_option(node)
+        {
+          text: node.attributes[:text],
+          value: node.attributes[:value],
+          selected: false
+        }
+      end
+    end
+  end
+end

data/lib/chat_sdk/gchat/event_parser.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+module ChatSDK
+  module GChat
+    class EventParser
+      class << self
+        def parse(payload)
+          type = payload["type"]
+
+          case type
+          when "MESSAGE"
+            parse_message(payload)
+          when "CARD_CLICKED"
+            parse_card_clicked(payload)
+          when "ADDED_TO_SPACE", "REMOVED_FROM_SPACE"
+            []
+          else
+            []
+          end
+        end
+
+        private
+
+        def parse_message(payload)
+          msg_data = payload["message"] || {}
+          sender = msg_data["sender"] || {}
+          space = msg_data["space"] || {}
+          thread_data = msg_data["thread"] || {}
+
+          author = ChatSDK::Author.new(
+            id: extract_id(sender["name"]),
+            name: sender["displayName"] || sender["name"] || "unknown",
+            platform: :gchat,
+            bot: sender["type"] == "BOT"
+          )
+
+          message = ChatSDK::Message.new(
+            id: extract_id(msg_data["name"]),
+            text: msg_data["text"] || msg_data["argumentText"] || "",
+            author: author,
+            thread_id: extract_id(thread_data["name"]),
+            channel_id: extract_id(space["name"]),
+            platform: :gchat,
+            raw: msg_data
+          )
+
+          if bot_mentioned?(msg_data)
+            [ChatSDK::Events::Mention.new(
+              message: message,
+              thread_id: message.thread_id,
+              channel_id: message.channel_id,
+              platform: :gchat,
+              adapter_name: :gchat,
+              raw: payload
+            )]
+          else
+            [ChatSDK::Events::SubscribedMessage.new(
+              message: message,
+              thread_id: message.thread_id,
+              channel_id: message.channel_id,
+              platform: :gchat,
+              adapter_name: :gchat,
+              raw: payload
+            )]
+          end
+        end
+
+        def parse_card_clicked(payload)
+          action = payload.dig("action", "actionMethodName") || payload.dig("common", "invokedFunction")
+          params = payload.dig("action", "parameters") || []
+          value = params.first&.dig("value")
+
+          user_data = payload["user"] || {}
+          space = payload.dig("message", "space") || payload["space"] || {}
+          thread_data = payload.dig("message", "thread") || {}
+
+          user = ChatSDK::Author.new(
+            id: extract_id(user_data["name"]),
+            name: user_data["displayName"] || user_data["name"] || "unknown",
+            platform: :gchat
+          )
+
+          [ChatSDK::Events::Action.new(
+            action_id: action || "unknown",
+            value: value,
+            user: user,
+            thread_id: extract_id(thread_data["name"]),
+            channel_id: extract_id(space["name"]),
+            platform: :gchat,
+            adapter_name: :gchat,
+            raw: payload
+          )]
+        end
+
+        def bot_mentioned?(msg_data)
+          annotations = msg_data["annotations"] || []
+          annotations.any? { |a| a["type"] == "USER_MENTION" && a.dig("userMention", "type") == "MENTION" }
+        end
+
+        def extract_id(resource_name)
+          return resource_name unless resource_name.is_a?(String)
+          resource_name.split("/").last || resource_name
+        end
+      end
+    end
+  end
+end

data/lib/chat_sdk/gchat/token_verifier.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module ChatSDK
+  module GChat
+    class TokenVerifier
+      EXPECTED_ISSUER = "chat@system.gserviceaccount.com"
+
+      def initialize(project_number)
+        @project_number = project_number.to_s
+      end
+
+      def verify!(token)
+        raise ChatSDK::SignatureVerificationError, "Missing bearer token" if token.nil? || token.empty?
+
+        payload = Google::Auth::IDTokens.verify_oidc(
+          token,
+          aud: @project_number
+        )
+
+        issuer = payload["iss"] || payload["email"]
+        unless issuer == EXPECTED_ISSUER
+          raise ChatSDK::SignatureVerificationError,
+            "Unexpected issuer: #{issuer} (expected #{EXPECTED_ISSUER})"
+        end
+
+        payload
+      rescue Google::Auth::IDTokens::VerificationError => e
+        raise ChatSDK::SignatureVerificationError, "Google ID token verification failed: #{e.message}"
+      end
+    end
+  end
+end

data/lib/chat_sdk/gchat.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require "chat_sdk"
+require "google/apps/chat/v1"
+require "googleauth"
+require "zeitwerk"
+
+module ChatSDK
+  module GChat
+    class << self
+      def loader
+        @loader ||= begin
+          loader = Zeitwerk::Loader.new
+          loader.tag = "chat_sdk-gchat"
+          loader.inflector.inflect("chat_sdk" => "ChatSDK", "gchat" => "GChat")
+          loader.push_dir("#{__dir__}/gchat", namespace: ChatSDK::GChat)
+          loader.setup
+          loader
+        end
+      end
+    end
+  end
+end
+
+ChatSDK::GChat.loader

metadata

@@ -0,0 +1,88 @@
+--- !ruby/object:Gem::Specification
+name: chat_sdk-gchat
+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: google-apps-chat-v1
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: googleauth
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+description: Google Chat bot adapter for the ChatSDK framework
+email:
+- eng@rootly.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/chat_sdk/gchat.rb
+- lib/chat_sdk/gchat/adapter.rb
+- lib/chat_sdk/gchat/card_v2_renderer.rb
+- lib/chat_sdk/gchat/event_parser.rb
+- lib/chat_sdk/gchat/token_verifier.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: Google Chat adapter for ChatSDK
+test_files: []