chat_sdk-slack 0.6.0 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1e7d8fc2f1b7131a6077f09cf438093c889cacbd14e714ce5c755e431b06100e
-  data.tar.gz: bd5d7332ecdd4ee0a703653672199eea4895c97b1dbdee6415bcf1af565c41f1
+  metadata.gz: 891f26261fed4ebb89b98b19ec57f2b304d9d3f8bedea493faa1457ac1bb742e
+  data.tar.gz: 9c1cc01f502f92642b89944aafc0ad24188d92c3c734d67735f00299c3bc6571
 SHA512:
-  metadata.gz: 6562ff69a5097cbfd41951eb0bd1a23cd44b2a9d8b0e37757d273cb8efaf782342b6a6bc9e8fcd744c3e17e692aa09c0d9f1bc3cf1fbdfdaae07ca60113b0d20
-  data.tar.gz: f6fb9463be08054efcc0f94c95f6f50e94b787db295cbe667011d9a7f73203ebc4edbca9221d2dae5a4e6e703276d2f02cd5bd11ed1289d68c37bccb807d4b68
+  metadata.gz: 4f59922bead78ae2f1f8a81cfc7f990d4ab2ef3c1fd193463def34897cb286696ac61c34699156435e21ed61c436099cfe1e3935ae84600b49c739f8beae8264
+  data.tar.gz: 07257e9662397d48d5c19798a2d8e5292b541ee600f046683a44b4b43b285dd1ab96900aa2eb0c5c593da885a98e26d8269c1c17a31b8c81d7cf7d549cefb3ca

data/lib/chat_sdk/slack/adapter.rb

@@ -222,6 +222,22 @@ module ChatSDK
         # This is a no-op but the capability is declared for streaming support
       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.
+      #
+      # Usage:
+      #   adapter.start_socket_mode(app_token: "xapp-...") do |event|
+      #     # event is a ChatSDK::Events::* instance
+      #   end
+      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
+
+        socket = SocketMode.new(app_token: app_token, bot_client: @client)
+        socket.start(&block)
+      end
+
       def mention(user_id)
         "<@#{user_id}>"
       end

data/lib/chat_sdk/slack/format_converter.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+module ChatSDK
+  module Slack
+    class FormatConverter < ChatSDK::Format::Converter
+      # Slack mrkdwn -> standard Markdown
+      def to_markdown(mrkdwn)
+        return "" if mrkdwn.nil? || mrkdwn.empty?
+
+        parts = split_code_blocks(mrkdwn)
+        parts.map.with_index { |part, i| i.odd? ? part : convert_mrkdwn_to_md(part) }.join
+      end
+
+      # Standard Markdown -> Slack mrkdwn
+      def from_markdown(markdown)
+        return "" if markdown.nil? || markdown.empty?
+
+        parts = split_code_blocks(markdown)
+        parts.map.with_index { |part, i| i.odd? ? part : convert_md_to_mrkdwn(part) }.join
+      end
+
+      private
+
+      # Splits text into alternating [text, code, text, code, ...] segments.
+      # Odd-indexed segments are code blocks (including their delimiters) and
+      # should be passed through without conversion.
+      def split_code_blocks(text)
+        # Match fenced code blocks (```...```) and inline code (`...`)
+        # The fenced block pattern must come first so triple backticks aren't
+        # eaten by the inline pattern.
+        text.split(/(```[\s\S]*?```|`[^`]+`)/)
+      end
+
+      # ── Slack mrkdwn → Markdown ──────────────────────────────────────────
+
+      def convert_mrkdwn_to_md(text)
+        result = text
+
+        # Mentions must be processed before generic links to avoid <#C123|name> matching <url|text>
+        # User mentions: <@U123ABC> -> @U123ABC
+        result = result.gsub(/<@([A-Z0-9]+)>/, '@\1')
+
+        # Channel mentions with label: <#C123|general> -> #general
+        result = result.gsub(/<#[A-Z0-9]+\|([^>]+)>/, '#\1')
+
+        # Channel mentions without label: <#C123> -> #C123
+        result = result.gsub(/<#([A-Z0-9]+)>/, '#\1')
+
+        # Special mentions: <!everyone>, <!here>, <!channel>
+        result = result.gsub("<!everyone>", "@everyone")
+        result = result.gsub("<!here>", "@here")
+        result = result.gsub("<!channel>", "@channel")
+
+        # Links with labels: <url|text> -> [text](url) (after mentions are consumed)
+        result = result.gsub(/<([^>|]+)\|([^>]+)>/) { "[#{Regexp.last_match(2)}](#{Regexp.last_match(1)})" }
+
+        # Bare links: <url> -> url (must come after labeled links)
+        result = result.gsub(/<([^@#!][^>|]*)>/, '\1')
+
+        # Bold: *text* -> **text** (only single asterisks, not already doubled)
+        # Negative lookbehind/lookahead to avoid matching inside ** pairs
+        result = result.gsub(/(?<!\*)\*(?!\*)(.+?)(?<!\*)\*(?!\*)/, '**\1**')
+
+        # Italic: _text_ -> *text*
+        result = result.gsub(/(?<![a-zA-Z0-9])_(.+?)_(?![a-zA-Z0-9])/, '*\1*')
+
+        # Strikethrough: ~text~ -> ~~text~~
+        result = result.gsub(/(?<!~)~(?!~)(.+?)(?<!~)~(?!~)/, '~~\1~~')
+
+        # HTML entities (must come last so earlier patterns can match on encoded text)
+        result = result.gsub("&gt;", ">")
+        result = result.gsub("&lt;", "<")
+        result.gsub("&amp;", "&")
+      end
+
+      # ── Markdown → Slack mrkdwn ──────────────────────────────────────────
+
+      def convert_md_to_mrkdwn(text)
+        result = text
+
+        # Links: [text](url) -> <url|text>
+        result = result.gsub(/\[([^\]]+)\]\(([^)]+)\)/) { "<#{Regexp.last_match(2)}|#{Regexp.last_match(1)}>" }
+
+        # Bold: **text** -> *text* (use placeholder to prevent italic pass from catching it)
+        result = result.gsub(/\*\*(.+?)\*\*/, "\x00BOLD\\1BOLD\x00")
+
+        # Italic: *text* -> _text_ (only single asterisks remaining after bold placeholder)
+        result = result.gsub(/(?<!\*)\*(?!\*)(.+?)(?<!\*)\*(?!\*)/, '_\1_')
+
+        # Restore bold placeholders
+        result = result.gsub(/\x00BOLD(.+?)BOLD\x00/, '*\1*')
+
+        # Strikethrough: ~~text~~ -> ~text~
+        result = result.gsub(/~~(.+?)~~/, '~\1~')
+
+        # Blockquote lines: > text -> &gt; text (only at line start)
+        result.gsub(/^> /m, "&gt; ")
+
+        # HTML entities for remaining special chars are not converted here —
+        # Slack handles raw < > & in normal text. Only blockquote > needs encoding.
+      end
+    end
+  end
+end

data/lib/chat_sdk/slack/socket_mode.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+module ChatSDK
+  module Slack
+    # Implements Slack Socket Mode: receives events over a WebSocket instead of
+    # incoming HTTP webhooks. Useful for local development, firewalled environments,
+    # or any setup that cannot expose a public URL.
+    #
+    # Requires the optional `faye-websocket` gem and an app-level token (xapp-*).
+    #
+    # Usage:
+    #   adapter.start_socket_mode(app_token: "xapp-...") do |event|
+    #     # event is a ChatSDK::Events::* instance
+    #   end
+    class SocketMode
+      PING_INTERVAL = 30
+
+      attr_reader :app_token, :bot_client
+
+      def initialize(app_token:, bot_client:)
+        @app_token = app_token
+        @bot_client = bot_client
+        @running = false
+      end
+
+      def start(&block)
+        raise ArgumentError, "start requires a block" unless block
+
+        load_websocket_driver!
+
+        @running = true
+        while @running
+          url = obtain_websocket_url
+          run_connection(url, &block)
+        end
+      end
+
+      def stop
+        @running = false
+        @ws&.close
+      end
+
+      private
+
+      def load_websocket_driver!
+        require "faye/websocket"
+      rescue LoadError
+        raise ChatSDK::ConfigurationError,
+          "Slack Socket Mode requires the 'faye-websocket' gem. " \
+          "Add gem 'faye-websocket' to your Gemfile."
+      end
+
+      def obtain_websocket_url
+        # apps.connections.open must be called with the app-level token, not the bot token
+        app_client = ::Slack::Web::Client.new(token: @app_token)
+        response = app_client.apps_connections_open
+        response["url"]
+      end
+
+      def run_connection(url, &block)
+        EM.run do
+          @ws = Faye::WebSocket::Client.new(url, nil, ping: PING_INTERVAL)
+
+          @ws.on :message do |ws_event|
+            handle_message(ws_event, &block)
+          end
+
+          @ws.on :close do |_event|
+            @ws = nil
+            EM.stop
+          end
+        end
+      rescue
+        # Let transient errors trigger a reconnect rather than crashing the loop
+        raise unless @running
+      end
+
+      def handle_message(ws_event, &block)
+        data = JSON.parse(ws_event.data)
+
+        # Acknowledge the envelope so Slack doesn't retry
+        acknowledge(data["envelope_id"]) if data["envelope_id"]
+
+        payload = data["payload"]
+        return unless payload
+
+        # Socket Mode wraps Events API payloads in an envelope. The inner payload
+        # matches the same structure our EventParser already handles from webhooks.
+        #
+        # Envelope types:
+        #   "events_api"       -> payload is an event_callback body
+        #   "interactive"      -> payload is a block_actions / view_submission body
+        #   "slash_commands"    -> payload is a slash command body
+        events = EventParser.parse(payload)
+        events.each { |event| block.call(event) }
+      rescue JSON::ParserError
+        # Ignore malformed frames (e.g. pong/control frames)
+      end
+
+      def acknowledge(envelope_id)
+        return unless envelope_id && @ws
+
+        @ws.send(JSON.generate({envelope_id: envelope_id}))
+      end
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: chat_sdk-slack
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.8.0
 platform: ruby
 authors:
 - Quentin Rousseau
@@ -48,7 +48,9 @@ files:
 - lib/chat_sdk/slack/adapter.rb
 - lib/chat_sdk/slack/block_kit_renderer.rb
 - lib/chat_sdk/slack/event_parser.rb
+- lib/chat_sdk/slack/format_converter.rb
 - lib/chat_sdk/slack/modal_renderer.rb
+- lib/chat_sdk/slack/socket_mode.rb
 homepage: https://github.com/rootlyhq/chat-sdk
 licenses:
 - MIT