chat_sdk-slack 1.1.0 → 1.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d93aacf823c427212c01efbdf76255caf3cd4a534b033b5557a9bbff9aaa8b97
-  data.tar.gz: a82ac7a769d42943060042cfaf16179b1a7c3482d9bfd9b268631b59a9723fa8
+  metadata.gz: d10492534a772bad66a756eabd3e3a89ef35f63ed61cdb84431979be6b844906
+  data.tar.gz: 720e5ea6b813a557335e59d2c2b42c9f5194a7f2dc8dfca0c6a7e937f36cbe2c
 SHA512:
-  metadata.gz: 49b4f95d68bb451922802284fae8ef36f9dffbc72ae33c44943618e5ca4141410c9f58cc885d353b96a2004ee12544cab4739cfeb0c3ef8fc2557c8bb731f3d1
-  data.tar.gz: f1ad880423c30b689eff5476070d3227310752b3122fd97c17a3fe34d8b52a3b0e05f7c67688b1bb47511dc839c0a1704fc3cfb210395d6654a966e119ff199e
+  metadata.gz: 4e4bd3615d525bf00f61885c3ff8830553e99644f4a2ba319ab3c547f611b87bb6035edb2eb1bc717b11102fa1454f6fe60d1c9c8f4f824156de09f516f20858
+  data.tar.gz: 6b33b090da4111d30602550197797a2169125caa3982e7ce22b44091b9cb5de38b4a22caf6090ca4aecf448314cb6017bcbe2115182ea67dec64c7ea2141be90

data/lib/chat_sdk/slack/adapter.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "stringio"
+
 module ChatSDK
   module Slack
     class Adapter < ChatSDK::Adapter::Base
@@ -9,33 +11,86 @@ module ChatSDK
         :scheduled_messages
 
       def initialize(bot_token: nil, signing_secret: nil,
-        client_id: nil, client_secret: nil, proxy: nil)
-        @bot_token = bot_token || ENV["SLACK_BOT_TOKEN"]
+        client_id: nil, client_secret: nil, proxy: nil, bot_user_id: nil,
+        installation_provider: nil, encryption_key: nil, webhook_verifier: nil,
+        native_streaming: true, stream_segment_max_age: 240)
+        @bot_token = bot_token.nil? ? ENV["SLACK_BOT_TOKEN"] : 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"]
+        @installation_provider = installation_provider
+        @webhook_verifier = webhook_verifier
+        encryption_key ||= ENV["SLACK_ENCRYPTION_KEY"]
+        @encryption_key = TokenEncryption.decode_key(encryption_key) if encryption_key
+        valid_segment_max_age = stream_segment_max_age.is_a?(Numeric) &&
+          !stream_segment_max_age.is_a?(Complex) &&
+          !(stream_segment_max_age.respond_to?(:nan?) && stream_segment_max_age.nan?) &&
+          (stream_segment_max_age.positive? || stream_segment_max_age == Float::INFINITY)
+        unless valid_segment_max_age
+          raise ChatSDK::ConfigurationError, "stream_segment_max_age must be a positive number"
+        end
+        @native_streaming = native_streaming
+        @native_streaming_broken = false
+        @stream_segment_max_age = stream_segment_max_age
+        @bot_user_ids = {}
+        @bot_user_id_mutex = Mutex.new
+        @client_cache = {}
+        @client_cache_mutex = Mutex.new
+        @context_key = :"chat_sdk_slack_context_#{object_id}"
         @proxy = proxy || ENV["HTTPS_PROXY"] || ENV["https_proxy"]
 
-        unless @bot_token || @client_id
-          raise ChatSDK::ConfigurationError, "Slack bot_token or client_id required"
+        if !@bot_token.nil? && !@bot_token.is_a?(String) && !@bot_token.respond_to?(:call)
+          raise ChatSDK::ConfigurationError, "Slack bot_token must be a String or callable"
+        end
+        if !@installation_provider.nil? && !@installation_provider.respond_to?(:get_installation) && !@installation_provider.respond_to?(:call)
+          raise ChatSDK::ConfigurationError, "Slack installation_provider must respond to get_installation or call"
+        end
+        if !@webhook_verifier.nil? && !@webhook_verifier.respond_to?(:call)
+          raise ChatSDK::ConfigurationError, "Slack webhook_verifier must be callable"
+        end
+        unless @bot_token || @client_id || @installation_provider
+          raise ChatSDK::ConfigurationError, "Slack bot_token, client_id or installation_provider required"
+        end
+        if @webhook_verifier.nil? && !@signing_secret
+          raise ChatSDK::ConfigurationError, "Slack signing_secret or webhook_verifier required"
         end
-        raise ChatSDK::ConfigurationError, "Slack signing_secret required" unless @signing_secret
 
-        if @bot_token
+        if @bot_token.is_a?(String)
           ::Slack.configure do |config|
             config.token = @bot_token
           end
-          @client = build_client(token: @bot_token)
+          @client = client_for_token(@bot_token)
         end
 
         @renderer = BlockKitRenderer.new
         @modal_renderer = ModalRenderer.new
-        @team_clients = {}
       end
 
       # Returns the per-request client (multi-workspace) or the static client (single-workspace).
       def client
-        ::Thread.current[:chat_sdk_slack_client] || @client
+        request_context = context
+        return client_for_token(request_context[:token]) if request_context && !request_context[:token].nil?
+        return @client if @bot_token.is_a?(String)
+        return unless @bot_token.respond_to?(:call)
+
+        token = @bot_token.call
+        if token.nil? || token == false || (token.respond_to?(:empty?) && token.empty?)
+          raise ChatSDK::ConfigurationError, "Slack bot_token resolver returned no token"
+        end
+        client_for_token(token)
+      end
+
+      def multi_workspace?
+        @bot_token.nil? || !@client_id.nil?
+      end
+
+      def with_bot_token(token, installation_id: nil)
+        previous_context = context
+        set_context(token: token, installation_id: installation_id)
+        yield
+      ensure
+        set_context(previous_context)
       end
 
       # Inject state store after initialization (e.g., from Chat instance).
@@ -45,25 +100,39 @@ module ChatSDK
 
       # --- Multi-workspace installation management ---
 
-      def set_installation(team_id, bot_token:, bot_user_id: nil, team_name: nil)
+      def set_installation(team_id, bot_token:, bot_user_id: nil, team_name: nil,
+        enterprise_id: nil, enterprise_install: nil)
         raise ChatSDK::ConfigurationError, "Multi-workspace mode requires state" unless @state
 
-        @team_clients.delete(team_id)
-        @state.set(installation_key(team_id), {
-          "bot_token" => bot_token,
+        installation = {
+          "bot_token" => @encryption_key ? TokenEncryption.encrypt(bot_token, @encryption_key) : bot_token,
           "bot_user_id" => bot_user_id,
           "team_name" => team_name
-        })
+        }
+        installation["enterprise_id"] = enterprise_id unless enterprise_id.nil?
+        installation["is_enterprise_install"] = enterprise_install unless enterprise_install.nil?
+        @state.set(installation_key(team_id), installation)
+        invalidate_bot_user_id(team_id)
       end
 
       def get_installation(team_id)
         return nil unless @state
 
-        @state.get(installation_key(team_id))
+        installation = @state.get(installation_key(team_id))
+        return installation unless installation.is_a?(Hash)
+
+        token_key = installation.key?("bot_token") ? "bot_token" : :bot_token
+        token = installation[token_key]
+        return installation unless TokenEncryption.encrypted?(token)
+        unless @encryption_key
+          raise ChatSDK::ConfigurationError, "Slack installation token is encrypted; configure encryption_key"
+        end
+
+        installation.merge(token_key => TokenEncryption.decrypt(token, @encryption_key))
       end
 
       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))
@@ -82,19 +151,39 @@ module ChatSDK
 
         result = temp_client.oauth_v2_access(**params)
 
-        team_id = result["team"]["id"]
+        team = hash_value(result, "team")
+        enterprise = hash_value(result, "enterprise")
+        enterprise_install = truthy_slack_value?(hash_value(result, "is_enterprise_install"))
+        enterprise_id = hash_value(enterprise, "id") || hash_value(result, "enterprise_id")
+        team_id = hash_value(team, "id")
+        installation_id = enterprise_install ? enterprise_id : team_id
+        access_token = hash_value(result, "access_token")
+        unless access_token && !access_token.empty? && installation_id && !installation_id.empty?
+          missing = enterprise_install ? "access_token or enterprise.id" : "access_token or team.id"
+          raise ChatSDK::ConfigurationError, "Slack OAuth response missing #{missing}"
+        end
+
         installation = {
-          "bot_token" => result["access_token"],
-          "bot_user_id" => result["bot_user_id"],
-          "team_name" => result["team"]["name"]
+          "bot_token" => access_token,
+          "bot_user_id" => hash_value(result, "bot_user_id"),
+          "team_name" => hash_value(team, "name") || hash_value(enterprise, "name")
         }
+        installation["enterprise_id"] = enterprise_id unless enterprise_id.nil?
+        installation["is_enterprise_install"] = enterprise_install if hash_key?(result, "is_enterprise_install")
 
-        set_installation(team_id,
+        set_installation(installation_id,
           bot_token: installation["bot_token"],
           bot_user_id: installation["bot_user_id"],
-          team_name: installation["team_name"])
-
-        {team_id: team_id, installation: installation}
+          team_name: installation["team_name"],
+          enterprise_id: enterprise_id,
+          enterprise_install: hash_key?(result, "is_enterprise_install") ? enterprise_install : nil)
+
+        {
+          team_id: installation_id,
+          enterprise_id: enterprise_id,
+          enterprise_install: enterprise_install,
+          installation: installation
+        }
       end
 
       def name
@@ -105,6 +194,18 @@ module ChatSDK
       def verify_request!(rack_request)
         body = rack_request.body.read
         rack_request.body.rewind
+        if @webhook_verifier
+          begin
+            result = @webhook_verifier.call(rack_request, body)
+          rescue => e
+            raise ChatSDK::SignatureVerificationError, "Slack webhook verifier failed: #{e.message}"
+          end
+          raise ChatSDK::SignatureVerificationError, "Slack webhook verifier rejected the request" unless result
+
+          rack_request.env["rack.input"] = StringIO.new(result) if result.is_a?(String)
+          return true
+        end
+
         timestamp = rack_request.env["HTTP_X_SLACK_REQUEST_TIMESTAMP"]
         signature = rack_request.env["HTTP_X_SLACK_SIGNATURE"]
 
@@ -139,21 +240,17 @@ module ChatSDK
       end
 
       def parse_events(rack_request)
+        set_context(nil)
         body = rack_request.body.read
         rack_request.body.rewind
 
         parsed = parse_body(body, rack_request.content_type)
         return [] unless parsed
 
-        # Multi-workspace: resolve per-team client from payload
-        # Clear any stale client from a previous request on this thread (Puma thread pool safety)
-        if @client_id
-          ::Thread.current[:chat_sdk_slack_client] = nil
-          team_id = parsed["team_id"] || parsed.dig("team", "id")
-          resolve_team_client(team_id) if team_id
-        end
+        return [] unless prepare_payload_context(parsed)
 
-        EventParser.parse(parsed)
+        events = EventParser.parse(parsed)
+        classify_message_events(events, parsed)
       end
 
       # Outbound
@@ -177,7 +274,27 @@ module ChatSDK
         )
       end
 
-      def edit_message(channel_id:, message_id:, message:)
+      def stream(channel_id:, thread_id:, stream:, options: {})
+        return unless thread_id && !thread_id.to_s.empty?
+        direct_message = channel_id.to_s.start_with?("D")
+        recipient_ids = [options[:recipient_user_id], options[:recipient_team_id]]
+        has_recipient_context = recipient_ids.all? { |id| id && !id.to_s.empty? }
+        return unless direct_message || has_recipient_context
+        return unless @native_streaming && !@native_streaming_broken
+
+        stream_client = client
+        NativeStream.new(
+          adapter: self,
+          client: stream_client,
+          channel_id: channel_id,
+          thread_id: thread_id,
+          stream: stream,
+          options: options,
+          max_age: @stream_segment_max_age
+        ).run
+      end
+
+      def edit_message(channel_id:, message_id:, message:, **_options)
         msg = ChatSDK::PostableMessage.from(message)
         params = {channel: channel_id, ts: message_id}
 
@@ -186,7 +303,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 +318,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 +434,24 @@ 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 context[:installation_id] if context && context[:installation_id]
+        return unless multi_workspace?
+
+        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 +463,17 @@ 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, payload|
+          payload ||= event.raw
+          set_context(nil)
+          next unless prepare_payload_context(payload)
+
+          classify_message_events([event], payload)
+          block.call(event)
+        end
       end
 
       def stop_socket_mode
@@ -354,28 +494,224 @@ module ChatSDK
 
       private
 
+      def monotonic_now
+        Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      end
+
       def build_client(token: nil)
         options = {}
-        options[:token] = token if token
+        options[:token] = token unless token.nil?
         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
+      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)
+        request_context = context
+        return request_context[:bot_user_id] if request_context && request_context[:bot_user_id]
+
+        return @bot_user_id if @bot_user_id
+
+        installation_id = if multi_workspace?
+          request_context&.[](:installation_id) || event_installation_id(event)
+        end
+        installation = resolve_installation(installation_id, enterprise_install: installation_enterprise_flag(event)) if installation_id && !request_context
+        installation_bot_user_id = hash_value(installation, "bot_user_id")
+        return installation_bot_user_id if installation_bot_user_id
+
+        token = request_context&.[](:token) || hash_value(installation, "bot_token")
+        current_client = token ? client_for_token(token) : client
+        return unless current_client
+
+        @bot_user_id_mutex.synchronize do
+          cache_key = multi_workspace? ? (installation_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 client_for_token(token)
+        @client_cache_mutex.synchronize do
+          return @client_cache[token] if @client_cache.key?(token)
+
+          @client_cache[token] = build_client(token: token)
+          @client_cache.shift while @client_cache.size > 256
+          @client_cache[token]
+        end
+      end
+
+      def context
+        ::Thread.current[@context_key]
+      end
+
+      def set_context(value)
+        ::Thread.current[@context_key] = value
+      end
+
+      def prepare_payload_context(payload)
+        return true unless multi_workspace?
+
+        identity = extract_installation(payload)
+        return true unless identity
+
+        installation = resolve_installation(
+          identity[:installation_id],
+          enterprise_install: identity[:enterprise_install]
+        )
+        token = hash_value(installation, "bot_token")
+        unless installation && token && token != false && !(token.respond_to?(:empty?) && token.empty?)
+          return true unless @bot_token.nil?
+
+          ChatSDK::Log.warn("Dropping Slack event without a resolved installation for #{identity[:installation_id]}")
+          return false
+        end
+
+        set_context({
+          token: token,
+          bot_user_id: hash_value(installation, "bot_user_id"),
+          installation_id: identity[:installation_id],
+          enterprise_install: identity[:enterprise_install],
+          team_id: identity[:team_id],
+          enterprise_id: identity[:enterprise_id]
+        })
+        true
+      end
+
+      def resolve_installation(installation_id, enterprise_install:)
+        return unless installation_id
 
-        cached = @team_clients[team_id]
-        if cached
-          ::Thread.current[:chat_sdk_slack_client] = cached
+        installation = if @installation_provider
+          if @installation_provider.respond_to?(:get_installation)
+            @installation_provider.get_installation(installation_id, enterprise_install: enterprise_install)
+          else
+            @installation_provider.call(installation_id, enterprise_install: enterprise_install)
+          end
+        else
+          get_installation(installation_id)
+        end
+        unless installation
+          ChatSDK::Log.warn("Slack installation not found for #{installation_id}")
+          return
+        end
+        token = hash_value(installation, "bot_token")
+        unless installation.is_a?(Hash) && token && token != false && !(token.respond_to?(:empty?) && token.empty?)
+          ChatSDK::Log.warn("Slack installation for #{installation_id} has no bot_token")
           return
         end
 
-        installation = get_installation(team_id)
-        return unless installation
+        installation
+      rescue => e
+        ChatSDK::Log.error("Could not resolve Slack installation #{installation_id}: #{e.message}")
+        nil
+      end
+
+      def extract_installation(payload)
+        return unless payload.is_a?(Hash)
+
+        if hash_value(payload, "type") == "event_callback"
+          authorization = Array(hash_value(payload, "authorizations")).first
+          enterprise_flag = if hash_key?(authorization, "is_enterprise_install")
+            hash_value(authorization, "is_enterprise_install")
+          else
+            hash_value(payload, "is_enterprise_install")
+          end
+          enterprise_install = truthy_slack_value?(enterprise_flag)
+          team_id = hash_value(authorization, "team_id") || hash_value(payload, "team_id")
+          enterprise_id = hash_value(authorization, "enterprise_id") || hash_value(payload, "enterprise_id")
+        elsif hash_key?(payload, "command")
+          enterprise_install = hash_value(payload, "is_enterprise_install") == "true"
+          team_id = hash_value(payload, "team_id")
+          enterprise_id = hash_value(payload, "enterprise_id")
+        else
+          enterprise_install = truthy_slack_value?(hash_value(payload, "is_enterprise_install"))
+          team = hash_value(payload, "team")
+          enterprise = hash_value(payload, "enterprise")
+          team_id = hash_value(team, "id") || hash_value(payload, "team_id")
+          enterprise_id = hash_value(enterprise, "id") || hash_value(payload, "enterprise_id")
+        end
+
+        installation_id = enterprise_install ? enterprise_id : team_id
+        return unless installation_id
+
+        {
+          installation_id: installation_id,
+          enterprise_install: enterprise_install,
+          team_id: team_id,
+          enterprise_id: enterprise_id
+        }
+      end
+
+      def event_installation_id(event)
+        raw = event.raw.is_a?(Hash) ? event.raw : {}
+        extract_installation(raw)&.[](:installation_id) ||
+          hash_value(raw, "team_id") ||
+          hash_value(hash_value(raw, "team"), "id")
+      end
+
+      def installation_enterprise_flag(event)
+        raw = event.raw.is_a?(Hash) ? event.raw : {}
+        identity = extract_installation(raw)
+        identity ? identity[:enterprise_install] : truthy_slack_value?(hash_value(raw, "is_enterprise_install"))
+      end
+
+      def hash_value(hash, key)
+        return unless hash.is_a?(Hash)
+
+        hash.key?(key) ? hash[key] : hash[key.to_sym]
+      end
+
+      def hash_key?(hash, key)
+        hash.is_a?(Hash) && (hash.key?(key) || hash.key?(key.to_sym))
+      end
 
-        new_client = build_client(token: installation["bot_token"])
-        @team_clients[team_id] = new_client
-        ::Thread.current[:chat_sdk_slack_client] = new_client
+      def truthy_slack_value?(value)
+        value == true || value == "true"
       end
 
       def installation_key(team_id)