chat_sdk-slack 1.1.0 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d93aacf823c427212c01efbdf76255caf3cd4a534b033b5557a9bbff9aaa8b97
-  data.tar.gz: a82ac7a769d42943060042cfaf16179b1a7c3482d9bfd9b268631b59a9723fa8
+  metadata.gz: 49b9759d50173e826b41f885fcba2f2c276d28574f187ac70bd1932d3da28ab4
+  data.tar.gz: 80c4806743ab979c9a6f024c5f7d8081152cdf8eaacb63607728e78518b88a5c
 SHA512:
-  metadata.gz: 49b4f95d68bb451922802284fae8ef36f9dffbc72ae33c44943618e5ca4141410c9f58cc885d353b96a2004ee12544cab4739cfeb0c3ef8fc2557c8bb731f3d1
-  data.tar.gz: f1ad880423c30b689eff5476070d3227310752b3122fd97c17a3fe34d8b52a3b0e05f7c67688b1bb47511dc839c0a1704fc3cfb210395d6654a966e119ff199e
+  metadata.gz: c79dccb6431aa33e0c9aa756287b7ec4342e97d4733b42e91f94e5ecfe44267e73dd404890dc13d600700985c6d958f03acad36f52121ec62ba010eb14145019
+  data.tar.gz: cebaf0452264d3b98802a1774fd834d77fa3be5b83a9f38848890c0b8ec742f976a0e510edf520f97f06e0375ca33c5fdce5af845043381cdb8a0ba1ee3b351d

data/lib/chat_sdk/slack/adapter.rb

@@ -9,11 +9,14 @@ module ChatSDK
         :scheduled_messages
 
       def initialize(bot_token: nil, signing_secret: nil,
-        client_id: nil, client_secret: nil, proxy: nil)
+        client_id: nil, client_secret: nil, proxy: nil, bot_user_id: nil)
         @bot_token = bot_token || ENV["SLACK_BOT_TOKEN"]
         @signing_secret = signing_secret || ENV["SLACK_SIGNING_SECRET"]
         @client_id = client_id || ENV["SLACK_CLIENT_ID"]
         @client_secret = client_secret || ENV["SLACK_CLIENT_SECRET"]
+        @bot_user_id = bot_user_id || ENV["SLACK_BOT_USER_ID"]
+        @bot_user_ids = {}
+        @bot_user_id_mutex = Mutex.new
         @proxy = proxy || ENV["HTTPS_PROXY"] || ENV["https_proxy"]
 
         unless @bot_token || @client_id
@@ -35,6 +38,8 @@ module ChatSDK
 
       # Returns the per-request client (multi-workspace) or the static client (single-workspace).
       def client
+        return @client unless @client_id
+
         ::Thread.current[:chat_sdk_slack_client] || @client
       end
 
@@ -54,6 +59,7 @@ module ChatSDK
           "bot_user_id" => bot_user_id,
           "team_name" => team_name
         })
+        invalidate_bot_user_id(team_id)
       end
 
       def get_installation(team_id)
@@ -64,6 +70,7 @@ module ChatSDK
 
       def delete_installation(team_id)
         @team_clients.delete(team_id)
+        invalidate_bot_user_id(team_id)
         return unless @state
 
         @state.delete(installation_key(team_id))
@@ -153,7 +160,8 @@ module ChatSDK
           resolve_team_client(team_id) if team_id
         end
 
-        EventParser.parse(parsed)
+        events = EventParser.parse(parsed)
+        classify_message_events(events, parsed)
       end
 
       # Outbound
@@ -177,7 +185,7 @@ module ChatSDK
         )
       end
 
-      def edit_message(channel_id:, message_id:, message:)
+      def edit_message(channel_id:, message_id:, message:, **_options)
         msg = ChatSDK::PostableMessage.from(message)
         params = {channel: channel_id, ts: message_id}
 
@@ -186,7 +194,7 @@ module ChatSDK
         client.chat_update(**params)
       end
 
-      def delete_message(channel_id:, message_id:)
+      def delete_message(channel_id:, message_id:, **_options)
         client.chat_delete(channel: channel_id, ts: message_id)
       end
 
@@ -201,17 +209,19 @@ module ChatSDK
       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)}
+        content = io.read
+        io.rewind if io.respond_to?(:rewind)
+        params = {channel_id: channel_id, filename: filename, content: content}
         params[:thread_ts] = thread_id if thread_id
         params[:initial_comment] = comment if comment
-        client.files_upload(**params)
+        client.files_upload_v2(**params)
       end
 
-      def add_reaction(channel_id:, message_id:, emoji:)
+      def add_reaction(channel_id:, message_id:, emoji:, **_options)
         client.reactions_add(channel: channel_id, timestamp: message_id, name: emoji)
       end
 
-      def remove_reaction(channel_id:, message_id:, emoji:)
+      def remove_reaction(channel_id:, message_id:, emoji:, **_options)
         client.reactions_remove(channel: channel_id, timestamp: message_id, name: emoji)
       end
 
@@ -315,11 +325,21 @@ module ChatSDK
         result["channel"]
       end
 
-      def start_typing(channel_id:, thread_id: nil)
+      def start_typing(channel_id:, thread_id: nil, message_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 concurrency_scope(event)
+        return unless @client_id
+
+        raw = event.raw.is_a?(Hash) ? event.raw : {}
+        raw_event = raw.is_a?(Hash) ? raw["event"] || raw[:event] || raw : {}
+        raw_team = raw.is_a?(Hash) ? raw["team"] || raw[:team] : nil
+        raw_team_id = raw_team.is_a?(Hash) ? raw_team["id"] || raw_team[:id] : raw_team
+        raw_team_id || raw["team_id"] || raw[:team_id] || raw_event["team_id"] || raw_event[:team_id] || raw_event["team"] || raw_event[:team]
+      end
+
       # Slack-specific: receive real-time events via Socket Mode WebSocket.
       # Requires the optional 'faye-websocket' gem and an app-level token (xapp-*).
       # Not part of the base adapter contract.
@@ -331,9 +351,18 @@ module ChatSDK
       def start_socket_mode(app_token: nil, &block)
         app_token ||= ENV["SLACK_APP_TOKEN"]
         raise ChatSDK::ConfigurationError, "Slack app_token required for socket mode" unless app_token
+        raise ArgumentError, "start requires a block" unless block
 
         @socket_mode = SocketMode.new(app_token: app_token, bot_client: client)
-        @socket_mode.start(&block)
+        @socket_mode.start do |event|
+          if @client_id
+            ::Thread.current[:chat_sdk_slack_client] = nil
+            team_id = concurrency_scope(event)
+            resolve_team_client(team_id) if team_id
+          end
+          classify_message_events([event], event.raw)
+          block.call(event)
+        end
       end
 
       def stop_socket_mode
@@ -361,13 +390,83 @@ module ChatSDK
         options.empty? ? ::Slack::Web::Client.new : ::Slack::Web::Client.new(options)
       end
 
+      def classify_message_events(events, payload)
+        events.each do |event|
+          next unless %i[mention subscribed_message direct_message].include?(event.type)
+
+          event.message.is_mention = classify_mention(event, payload)
+        end
+        events
+      end
+
+      def classify_mention(event, payload)
+        raw_event = payload["event"] || {}
+        return true if raw_event["type"] == "app_mention"
+
+        bot_user_id = resolve_bot_user_id(event)
+        return true if event.type == :mention && bot_user_id.nil?
+        return nil if bot_user_id.nil?
+
+        text = raw_event["text"].to_s
+        masked_text = ChatSDK::Format::Mentions.mask_code_spans(text)
+        text_mentions_bot = /<@#{Regexp.escape(bot_user_id)}(?:\|[^>]*)?>/.match?(masked_text)
+        text_mentions_bot || rich_text_mentions_bot?(raw_event["blocks"], bot_user_id)
+      end
+
+      def resolve_bot_user_id(event)
+        team_id = concurrency_scope(event) if @client_id
+        if @client_id
+          installation = get_installation(team_id) if team_id
+          return installation["bot_user_id"] if installation && installation["bot_user_id"]
+        end
+
+        return @bot_user_id if @bot_user_id
+
+        current_client = if @client_id
+          resolve_team_client(team_id) if team_id
+        else
+          @client
+        end
+        return unless current_client
+
+        @bot_user_id_mutex.synchronize do
+          cache_key = @client_id ? (team_id || :default) : :default
+          return @bot_user_ids[cache_key] if @bot_user_ids.key?(cache_key)
+
+          bot_user_id = begin
+            current_client.auth_test["user_id"]
+          rescue ::Slack::Web::Api::Errors::SlackError, Faraday::Error, SocketError, Timeout::Error
+            nil
+          end
+          @bot_user_ids[cache_key] = bot_user_id if bot_user_id
+          bot_user_id
+        end
+      end
+
+      def invalidate_bot_user_id(team_id)
+        @bot_user_id_mutex.synchronize { @bot_user_ids.delete(team_id) }
+      end
+
+      def rich_text_mentions_bot?(blocks, bot_user_id)
+        Array(blocks).any? { |block| rich_text_element_mentions_bot?(block, bot_user_id) }
+      end
+
+      def rich_text_element_mentions_bot?(element, bot_user_id)
+        return false unless element.is_a?(Hash)
+        return false if %w[rich_text_preformatted preformatted code].include?(element["type"])
+        return false if element.dig("style", "code")
+        return true if element["type"] == "user" && element["user_id"] == bot_user_id
+
+        Array(element["elements"]).any? { |child| rich_text_element_mentions_bot?(child, bot_user_id) }
+      end
+
       def resolve_team_client(team_id)
         return unless @client_id && @state
 
         cached = @team_clients[team_id]
         if cached
           ::Thread.current[:chat_sdk_slack_client] = cached
-          return
+          return cached
         end
 
         installation = get_installation(team_id)
@@ -376,6 +475,7 @@ module ChatSDK
         new_client = build_client(token: installation["bot_token"])
         @team_clients[team_id] = new_client
         ::Thread.current[:chat_sdk_slack_client] = new_client
+        new_client
       end
 
       def installation_key(team_id)

data/lib/chat_sdk/slack/block_kit_renderer.rb

@@ -15,7 +15,15 @@ module ChatSDK
       def render_card(node)
         @used_native_table = false
         @chart_count = 0
-        node.children.map { |child| render_node(child) }.compact
+        blocks = []
+        if node.attributes[:title]
+          blocks << {type: "header", text: {type: "plain_text", text: truncate_text(node.attributes[:title], 150)}}
+        end
+        if node.attributes[:subtitle]
+          blocks << {type: "context", elements: [{type: "mrkdwn", text: truncate_mrkdwn(node.attributes[:subtitle], 3000)}]}
+        end
+        blocks.concat(node.children.map { |child| render_node(child) }.compact)
+        blocks
       end
 
       def render_node(node)
@@ -28,19 +36,20 @@ module ChatSDK
         when :actions then render_actions(node)
         when :table then render_table(node)
         when :chart then render_chart(node)
+        when :text_input then {type: "section", text: {type: "mrkdwn", text: truncate_mrkdwn(node.attributes[:label], 3000)}}
         end
       end
 
       def render_text(node)
         {
           type: "section",
-          text: {type: "mrkdwn", text: node.attributes[:content]}
+          text: {type: "mrkdwn", text: truncate_mrkdwn(node.attributes[:content], 3000)}
         }
       end
 
       def render_image(node)
         block = {type: "image", image_url: node.attributes[:url]}
-        block[:alt_text] = node.attributes[:alt] || " "
+        block[:alt_text] = truncate_text(node.attributes[:alt] || " ", 2000)
         block
       end
 
@@ -48,7 +57,7 @@ module ChatSDK
         {
           type: "section",
           fields: node.children.map do |field|
-            {type: "mrkdwn", text: "*#{field.attributes[:label]}*\n#{field.attributes[:value]}"}
+            {type: "mrkdwn", text: truncate_mrkdwn("*#{field.attributes[:label]}*\n#{field.attributes[:value]}", 2000)}
           end
         }
       end
@@ -57,7 +66,7 @@ module ChatSDK
         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")}
+          block[:text] = {type: "mrkdwn", text: truncate_mrkdwn(text_children.map { |t| t.attributes[:content] }.join("\n"), 3000)}
         end
         block
       end
@@ -80,7 +89,7 @@ module ChatSDK
       def render_button(node)
         btn = {
           type: "button",
-          text: {type: "plain_text", text: node.attributes[:text]},
+          text: {type: "plain_text", text: truncate_text(node.attributes[:text], 75)},
           action_id: node.attributes[:id]
         }
         btn[:value] = node.attributes[:value] if node.attributes[:value]
@@ -89,16 +98,19 @@ module ChatSDK
         elsif node.attributes[:style] == :danger
           btn[:style] = "danger"
         end
+        btn[:visible_to_user_ids] = node.attributes[:visible_to] if node.attributes[:visible_to]&.any?
         btn
       end
 
       def render_link_button(node)
-        {
+        button = {
           type: "button",
-          text: {type: "plain_text", text: node.attributes[:text]},
+          text: {type: "plain_text", text: truncate_text(node.attributes[:text], 75)},
           url: node.attributes[:url],
           action_id: node.attributes[:id] || "link_#{node.attributes[:url].hash.abs}"
         }
+        button[:visible_to_user_ids] = node.attributes[:visible_to] if node.attributes[:visible_to]&.any?
+        button
       end
 
       def render_select(node)
@@ -108,18 +120,18 @@ module ChatSDK
           options: node.children.map { |opt| render_option(opt) }
         }
         if node.attributes[:placeholder]
-          sel[:placeholder] = {type: "plain_text", text: node.attributes[:placeholder]}
+          sel[:placeholder] = {type: "plain_text", text: truncate_text(node.attributes[:placeholder], 150)}
         end
         sel
       end
 
       def render_option(node)
         opt = {
-          text: {type: "plain_text", text: node.attributes[:text]},
+          text: {type: "plain_text", text: truncate_text(node.attributes[:text], 75)},
           value: node.attributes[:value]
         }
         if node.attributes[:description]
-          opt[:description] = {type: "plain_text", text: node.attributes[:description]}
+          opt[:description] = {type: "plain_text", text: truncate_text(node.attributes[:description], 75)}
         end
         opt
       end
@@ -190,7 +202,46 @@ module ChatSDK
       end
 
       def fallback_block(text)
-        {type: "section", text: {type: "mrkdwn", text: "```#{text}```"}}
+        {type: "section", text: {type: "mrkdwn", text: truncate_mrkdwn("```#{text}```", 3000)}}
+      end
+
+      def truncate_text(text, limit)
+        text = text.to_s
+        return text if text.length <= limit
+
+        "#{text[0, limit - 1]}…"
+      end
+
+      def truncate_mrkdwn(text, limit)
+        text = text.to_s
+        return text if text.length <= limit
+
+        prefix = clean_prefix(text[0, limit - 1])
+        4.times do
+          bold_close = prefix.count("*").odd? ? "*" : ""
+          fence_close = open_fence?(prefix) ? "\n```" : ""
+          available = limit - 1 - bold_close.length - fence_close.length
+          next_prefix = clean_prefix(text[0, available])
+          break if next_prefix == prefix
+
+          prefix = next_prefix
+        end
+
+        bold_close = prefix.count("*").odd? ? "*" : ""
+        fence_close = open_fence?(prefix) ? "\n```" : ""
+        suffix = "#{bold_close}…#{fence_close}"
+        prefix = clean_prefix(prefix[0, limit - suffix.length]) while prefix.length + suffix.length > limit
+        "#{prefix}#{suffix}"
+      end
+
+      def clean_prefix(text)
+        text
+          .sub(/<(?:[@#!]|[a-z][a-z\d+.-]*(?::|$))[^>]*\z/i, "")
+          .sub(/&(?:#?[a-z\d]*)?\z/i, "")
+      end
+
+      def open_fence?(text)
+        text.scan("```").length.odd?
       end
     end
   end

data/lib/chat_sdk/slack/event_parser.rb

@@ -50,7 +50,7 @@ module ChatSDK
           )
           message = ChatSDK::Message.new(
             id: event["ts"],
-            text: event["text"] || "",
+            text: message_text(event),
             author: author,
             thread_id: event["thread_ts"] || event["ts"],
             channel_id: event["channel"],
@@ -80,7 +80,7 @@ module ChatSDK
           )
           message = ChatSDK::Message.new(
             id: event["ts"],
-            text: event["text"] || "",
+            text: message_text(event),
             author: author,
             thread_id: event["thread_ts"] || event["ts"],
             channel_id: event["channel"],
@@ -130,6 +130,37 @@ module ChatSDK
           )]
         end
 
+        def message_text(event)
+          blocks = event["blocks"]
+          text = if blocks.is_a?(Array) && !blocks.empty? && blocks.all? { |block| %w[section header context image divider actions table].include?(block["type"]) }
+            blocks.filter_map { |block| block_text(block) }.join("\n")
+          else
+            event["text"] || ""
+          end
+          FormatConverter.new.normalize_inbound_text(text)
+        end
+
+        def block_text(block)
+          case block["type"]
+          when "section", "header"
+            texts = [block.dig("text", "text")]
+            texts.concat(Array(block["fields"]).map { |field| field["text"] })
+            texts.compact.reject(&:empty?).join("\n")
+          when "context"
+            Array(block["elements"]).filter_map { |element| element.dig("text") }.reject(&:empty?).join("\n")
+          when "image"
+            block["alt_text"]
+          when "actions"
+            Array(block["elements"]).filter_map do |element|
+              element.dig("text", "text") || element.dig("placeholder", "text")
+            end.reject(&:empty?).join(" ")
+          when "table"
+            Array(block["rows"]).map do |row|
+              Array(row).map { |cell| cell.dig("text") || cell.to_s }.join(" | ")
+            end.join("\n")
+          end
+        end
+
         def parse_message_deleted(event, payload)
           previous = event["previous_message"]
           message_id = event["deleted_ts"] || previous&.dig("ts")

data/lib/chat_sdk/slack/format_converter.rb

@@ -19,6 +19,23 @@ module ChatSDK
         parts.map.with_index { |part, i| i.odd? ? part : convert_md_to_mrkdwn(part) }.join
       end
 
+      def normalize_inbound_text(text)
+        return "" if text.nil? || text.empty?
+
+        split_code_blocks(text).map.with_index do |part, index|
+          if index.odd?
+            part
+          else
+            part
+              .gsub("<!here>", "@here")
+              .gsub("<!channel>", "@channel")
+              .gsub("<!everyone>", "@everyone")
+              .gsub(/<!subteam\^[^|>]+\|(@[^>]+)>/, '\1')
+              .gsub(/<(?:mailto|tel):[^>|]+\|([^>]+)>/, '\1')
+          end
+        end.join
+      end
+
       private
 
       # ── Slack mrkdwn → Markdown ──────────────────────────────────────────

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: chat_sdk-slack
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 1.2.0
 platform: ruby
 authors:
 - Quentin Rousseau
@@ -15,14 +15,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0.1'
+        version: '1.2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0.1'
+        version: '1.2'
 - !ruby/object:Gem::Dependency
   name: slack-ruby-client
   requirement: !ruby/object:Gem::Requirement