chat_sdk-slack 1.0.0 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 17c05a1b3391a1d2f8a4a248fc2ee2e4048b5fbdf608cfd10becba0239f76cde
-  data.tar.gz: a5be2b1d3ac3738c28d92e53bc3209b4d565ceb3f08635e469c65e606e43cdc7
+  metadata.gz: d93aacf823c427212c01efbdf76255caf3cd4a534b033b5557a9bbff9aaa8b97
+  data.tar.gz: a82ac7a769d42943060042cfaf16179b1a7c3482d9bfd9b268631b59a9723fa8
 SHA512:
-  metadata.gz: f405de4643b259ed5477d52f2f6b733b4af2fb12eeb184a019ac9ac98d0aa982a8a156752f48aae95989e3ff6a1d5bf236255056e2e75c0d2ea58f7f886a1320
-  data.tar.gz: 99a0b0a0e7b9d85f17b203c483252dadd24a82269cce6b8776fe09153bc99215372c6275975dbef80c810a46aba34752efc85946546107cb21927edd11350d4d
+  metadata.gz: 49b4f95d68bb451922802284fae8ef36f9dffbc72ae33c44943618e5ca4141410c9f58cc885d353b96a2004ee12544cab4739cfeb0c3ef8fc2557c8bb731f3d1
+  data.tar.gz: f1ad880423c30b689eff5476070d3227310752b3122fd97c17a3fe34d8b52a3b0e05f7c67688b1bb47511dc839c0a1704fc3cfb210395d6654a966e119ff199e

data/lib/chat_sdk/slack/adapter.rb

@@ -9,11 +9,12 @@ module ChatSDK
         :scheduled_messages
 
       def initialize(bot_token: nil, signing_secret: nil,
-        client_id: nil, client_secret: nil)
+        client_id: nil, client_secret: nil, proxy: 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"]
+        @proxy = proxy || ENV["HTTPS_PROXY"] || ENV["https_proxy"]
 
         unless @bot_token || @client_id
           raise ChatSDK::ConfigurationError, "Slack bot_token or client_id required"
@@ -24,7 +25,7 @@ module ChatSDK
           ::Slack.configure do |config|
             config.token = @bot_token
           end
-          @client = ::Slack::Web::Client.new(token: @bot_token)
+          @client = build_client(token: @bot_token)
         end
 
         @renderer = BlockKitRenderer.new
@@ -71,7 +72,7 @@ module ChatSDK
       def handle_oauth_callback(code:, redirect_uri: nil)
         raise ChatSDK::ConfigurationError, "client_id required for OAuth" unless @client_id
 
-        temp_client = ::Slack::Web::Client.new
+        temp_client = build_client
         params = {
           client_id: @client_id,
           client_secret: @client_secret,
@@ -267,6 +268,10 @@ module ChatSDK
         client.views_open(trigger_id: trigger_id, view: view)
       end
 
+      def update_modal(view_id:, modal:)
+        client.views_update(view_id: view_id, view: @modal_renderer.render(modal))
+      end
+
       def publish_home_view(user_id:, view:)
         client.views_publish(user_id: user_id, view: view)
       end
@@ -295,6 +300,21 @@ module ChatSDK
         )
       end
 
+      def send_to_response_url(response_url:, message:)
+        msg = ChatSDK::PostableMessage.from(message)
+        payload = {}
+        apply_message_params(payload, msg)
+        Faraday.post(response_url) do |req|
+          req.headers["Content-Type"] = "application/json"
+          req.body = JSON.generate(payload)
+        end
+      end
+
+      def fetch_thread(channel_id:, thread_id: nil)
+        result = client.conversations_info(channel: channel_id)
+        result["channel"]
+      end
+
       def start_typing(channel_id:, thread_id: nil)
         # Slack doesn't have a native typing indicator API for bots
         # This is a no-op but the capability is declared for streaming support
@@ -312,8 +332,12 @@ module ChatSDK
         app_token ||= ENV["SLACK_APP_TOKEN"]
         raise ChatSDK::ConfigurationError, "Slack app_token required for socket mode" unless app_token
 
-        socket = SocketMode.new(app_token: app_token, bot_client: client)
-        socket.start(&block)
+        @socket_mode = SocketMode.new(app_token: app_token, bot_client: client)
+        @socket_mode.start(&block)
+      end
+
+      def stop_socket_mode
+        @socket_mode&.stop
       end
 
       def mention(user_id)
@@ -330,6 +354,13 @@ module ChatSDK
 
       private
 
+      def build_client(token: nil)
+        options = {}
+        options[:token] = token if token
+        options[:proxy] = @proxy if @proxy
+        options.empty? ? ::Slack::Web::Client.new : ::Slack::Web::Client.new(options)
+      end
+
       def resolve_team_client(team_id)
         return unless @client_id && @state
 
@@ -342,7 +373,7 @@ module ChatSDK
         installation = get_installation(team_id)
         return unless installation
 
-        new_client = ::Slack::Web::Client.new(token: installation["bot_token"])
+        new_client = build_client(token: installation["bot_token"])
         @team_clients[team_id] = new_client
         ::Thread.current[:chat_sdk_slack_client] = new_client
       end

data/lib/chat_sdk/slack/block_kit_renderer.rb

@@ -13,6 +13,8 @@ module ChatSDK
       private
 
       def render_card(node)
+        @used_native_table = false
+        @chart_count = 0
         node.children.map { |child| render_node(child) }.compact
       end
 
@@ -24,6 +26,8 @@ module ChatSDK
         when :fields then render_fields(node)
         when :section then render_section(node)
         when :actions then render_actions(node)
+        when :table then render_table(node)
+        when :chart then render_chart(node)
         end
       end
 
@@ -93,7 +97,7 @@ module ChatSDK
           type: "button",
           text: {type: "plain_text", text: node.attributes[:text]},
           url: node.attributes[:url],
-          action_id: "link_#{node.attributes[:url].hash.abs}"
+          action_id: node.attributes[:id] || "link_#{node.attributes[:url].hash.abs}"
         }
       end
 
@@ -119,6 +123,75 @@ module ChatSDK
         end
         opt
       end
+
+      def render_table(node)
+        headers = Array(node.attributes[:headers])
+        rows = Array(node.attributes[:rows])
+        char_count = (headers + rows.flatten).sum { |cell| cell.to_s.length }
+        if @used_native_table || rows.length > 100 || headers.length > 20 || char_count > 10_000
+          return fallback_block(ChatSDK::Cards::Renderer.new.render(node))
+        end
+
+        @used_native_table = true
+        rendered_rows = [headers, *rows].map do |row|
+          Array(row).map { |cell| {type: "raw_text", text: cell.to_s.empty? ? " " : cell.to_s} }
+        end
+        return {type: "table", rows: rendered_rows} if rows.empty?
+
+        block = {
+          type: "data_table",
+          caption: node.attributes[:caption] || "Table",
+          rows: rendered_rows
+        }
+        block[:page_size] = node.attributes[:page_size].to_i.clamp(1, 100) if node.attributes[:page_size]
+        block
+      end
+
+      def render_chart(node)
+        return fallback_block(node.fallback_text) if @chart_count >= 2
+
+        block = chart_block(node)
+        return fallback_block(node.fallback_text) unless block
+
+        @chart_count += 1
+        block
+      end
+
+      def chart_block(node)
+        title = node.attributes[:title].to_s
+        return if title.empty? || title.length > 50
+
+        type = node.attributes[:chart_type].to_sym
+        if type == :pie
+          segments = Array(node.attributes[:segments])
+          return unless segments.length.between?(1, 12) && segments.all? { |segment| valid_chart_label?(value_for(segment, :label)) && value_for(segment, :value).to_f.positive? }
+
+          return {type: "data_visualization", title: title, chart: {type: "pie", segments: segments}}
+        end
+
+        categories = Array(node.attributes[:categories])
+        series = Array(node.attributes[:series])
+        return unless %i[bar area line].include?(type)
+        return unless categories.length.between?(1, 20) && categories.all? { |category| valid_chart_label?(category) }
+        return unless series.length.between?(1, 12) && series.all? { |item| valid_chart_label?(value_for(item, :name)) }
+
+        axis = {categories: categories}
+        axis[:x_label] = node.attributes[:x_label] if node.attributes[:x_label]
+        axis[:y_label] = node.attributes[:y_label] if node.attributes[:y_label]
+        {type: "data_visualization", title: title, chart: {type: type.to_s, series: series, axis_config: axis}}
+      end
+
+      def valid_chart_label?(label)
+        label.to_s.length.between?(1, 20)
+      end
+
+      def value_for(hash, key)
+        hash[key] || hash[key.to_s]
+      end
+
+      def fallback_block(text)
+        {type: "section", text: {type: "mrkdwn", text: "```#{text}```"}}
+      end
     end
   end
 end

data/lib/chat_sdk/slack/event_parser.rb

@@ -68,6 +68,8 @@ module ChatSDK
         end
 
         def parse_message_event(event, payload)
+          return parse_message_updated(event, payload) if event["subtype"] == "message_changed"
+          return parse_message_deleted(event, payload) if event["subtype"] == "message_deleted"
           return [] if event["subtype"] && event["subtype"] != "file_share"
           return [] if event["bot_id"]
 
@@ -108,6 +110,72 @@ module ChatSDK
           end
         end
 
+        def parse_message_updated(event, payload)
+          return [] if event["hidden"]
+
+          message_data = event["message"]
+          return [] unless message_data
+
+          channel_id = event["channel"] || message_data["channel"]
+          message = slack_message(message_data, channel_id)
+          previous = slack_message(event["previous_message"], channel_id) if event["previous_message"]
+          [ChatSDK::Events::MessageUpdated.new(
+            message: message,
+            previous_message: previous,
+            thread_id: message.thread_id,
+            channel_id: channel_id,
+            platform: :slack,
+            adapter_name: :slack,
+            raw: payload
+          )]
+        end
+
+        def parse_message_deleted(event, payload)
+          previous = event["previous_message"]
+          message_id = event["deleted_ts"] || previous&.dig("ts")
+          return [] unless message_id
+
+          channel_id = event["channel"] || previous&.dig("channel")
+          previous_message = slack_message(previous, channel_id) if previous
+          thread_id = previous&.dig("thread_ts") || message_id
+          [ChatSDK::Events::MessageDeleted.new(
+            message_id: message_id,
+            previous_message: previous_message,
+            thread_id: thread_id,
+            channel_id: channel_id,
+            deleted_at: slack_time(event["event_ts"] || event["ts"]),
+            platform: :slack,
+            adapter_name: :slack,
+            raw: payload
+          )]
+        end
+
+        def slack_message(data, channel_id)
+          user_id = data["user"] || data.dig("bot_profile", "user_id") || "unknown"
+          ChatSDK::Message.new(
+            id: data["ts"],
+            text: data["text"] || "",
+            author: ChatSDK::Author.new(
+              id: user_id,
+              name: data["username"] || user_id,
+              platform: :slack,
+              bot: !!data["bot_id"],
+              system: user_id == "USLACK"
+            ),
+            thread_id: data["thread_ts"] || data["ts"],
+            channel_id: channel_id,
+            platform: :slack,
+            timestamp: slack_time(data["ts"]),
+            raw: data
+          )
+        end
+
+        def slack_time(value)
+          Time.at(Float(value)) if value
+        rescue ArgumentError, TypeError
+          nil
+        end
+
         def parse_reaction(event, payload, added:)
           [ChatSDK::Events::Reaction.new(
             emoji: event["reaction"],

data/lib/chat_sdk/slack/modal_renderer.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "date"
+
 module ChatSDK
   module Slack
     class ModalRenderer
@@ -49,10 +51,37 @@ module ChatSDK
           }
           el[:placeholder] = {type: "plain_text", text: node.attributes[:placeholder]} if node.attributes[:placeholder]
           el
+        when :date
+          el = {type: "datepicker", action_id: node.attributes[:id]}
+          initial_date = valid_initial_date(node.attributes[:initial_value])
+          el[:initial_date] = initial_date if initial_date
+          el[:placeholder] = {type: "plain_text", text: node.attributes[:placeholder]} if node.attributes[:placeholder]
+          el
+        when :number
+          el = {
+            type: "number_input",
+            action_id: node.attributes[:id],
+            is_decimal_allowed: !!node.attributes[:decimal]
+          }
+          el[:min_value] = node.attributes[:min].to_s unless node.attributes[:min].nil?
+          el[:max_value] = node.attributes[:max].to_s unless node.attributes[:max].nil?
+          el[:initial_value] = node.attributes[:initial_value].to_s unless node.attributes[:initial_value].nil?
+          el[:placeholder] = {type: "plain_text", text: node.attributes[:placeholder]} if node.attributes[:placeholder]
+          el
         end
         block
       end
 
+      def valid_initial_date(value)
+        return unless value
+
+        parsed = Date.iso8601(value.to_s)
+        value.to_s if parsed.iso8601 == value.to_s
+      rescue Date::Error
+        ChatSDK::Log.warn("Ignoring invalid modal initial date: #{value.inspect}")
+        nil
+      end
+
       def render_text(node)
         {
           type: "section",

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: chat_sdk-slack
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.1.0
 platform: ruby
 authors:
 - Quentin Rousseau