slack_socket_mode_bot 0.9.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: ea84a2e36d8b349ef867322ad4e932703dc5fa7eea1397f693268977aecfb001
+  data.tar.gz: 1802e47527f56357fa5a3d564f61f91a6a3f3741bb107227dad18be8beedb08f
+SHA512:
+  metadata.gz: 4b5cbb57859b8f34a2d45c8869d2f197ef84f24d7554c12027e331a783edc510357dd6d7cd1b199db98870b17abb2a27e2ca1f70fc4fce0151fa82392db4456a
+  data.tar.gz: e84f97c7a0dbe89e249315f5142b7c275de3b7cfb4f90127727d7d9e943f14c1eb493994a56554d8af22c7a2248e9e5a9c873a2a08e3f21bd7614265d5fa383b

data/README.md

@@ -0,0 +1,127 @@
+# SlackSocketModeBot
+
+This is a simple Ruby wrapper for the [Slack's Socket Mode API](https://api.slack.com/apis/socket-mode).
+It allows you to write a Slack bot without exposing a public HTTP endpoint.
+
+## Usage
+
+First, set up your Slack app for Socket Mode by reading [the official document](https://api.slack.com/apis/socket-mode).
+
+Then, run the following script.
+
+```ruby
+# simple echo bot
+
+require "slack_socket_mode_bot"
+require "logger"
+
+# Slack's Bot User OAuth Token
+# You can create this token with: https://api.slack.com/apps/ - "OAuth & Permissions" - "OAuth Tokens for Your Workspace"
+SLACK_BOT_TOKEN = "xoxb-..."
+
+# Slack's App-Level Token
+# You can create this token with: https://api.slack.com/apps/ - "Basic Information" - "App-Level Tokens"
+SLACK_APP_TOKEN = "xapp-..."
+
+logger = Logger.new(STDOUT, level: Logger::Severity::INFO)
+
+bot = SlackSocketModeBot.new(token: SLACK_BOT_TOKEN, app_token: SLACK_APP_TOKEN, logger: logger) do |data|
+  # Event handler. A sample data is
+  #
+  # {
+  #   "type": "events_api",
+  #   "envelope_id": "...",
+  #   "accepts_response_payload": false,
+  #   "payload": {
+  #     "type": "event_callback",
+  #     "event": {
+  #       "type": "app_mention",
+  #       "text": "hello",
+  #       ...
+  #     },
+  #     ...
+  #   }
+  # }
+  #
+  # See https://api.slack.com/apis/socket-mode#events in detail
+
+  if data[:type] == "events_api" && data[:payload][:event][:type] == "app_mention"
+    event = data[:payload][:event]
+
+    text = event[:text]
+
+    echo_text = "echo:" + text
+
+    bot.call("chat.postMessage", { channel: event[:channel], text: echo_text })
+  end
+
+rescue Exception
+  puts $!.full_message
+end
+
+# Start the communication
+bot.run
+```
+
+```
+$ ruby example/echo_bot.rb
+I, [20XX-XX-XXTXX:XX:XX.XXXXXX #XXXXXX]  INFO -- : [ws:2560] websocket open
+I, [20XX-XX-XXTXX:XX:XX.XXXXXX #XXXXXX]  INFO -- : [ws:2600] websocket open
+I, [20XX-XX-XXTXX:XX:XX.XXXXXX #XXXXXX]  INFO -- : [ws:2560] slack hello
+I, [20XX-XX-XXTXX:XX:XX.XXXXXX #XXXXXX]  INFO -- : [ws:2560] active connection count: 4
+I, [20XX-XX-XXTXX:XX:XX.XXXXXX #XXXXXX]  INFO -- : [ws:2600] slack hello
+I, [20XX-XX-XXTXX:XX:XX.XXXXXX #XXXXXX]  INFO -- : [ws:2600] active connection count: 4
+I, [20XX-XX-XXTXX:XX:XX.XXXXXX #XXXXXX]  INFO -- : [ws:2640] websocket open
+I, [20XX-XX-XXTXX:XX:XX.XXXXXX #XXXXXX]  INFO -- : [ws:2640] slack hello
+I, [20XX-XX-XXTXX:XX:XX.XXXXXX #XXXXXX]  INFO -- : [ws:2640] active connection count: 4
+I, [20XX-XX-XXTXX:XX:XX.XXXXXX #XXXXXX]  INFO -- : [ws:2680] websocket open
+I, [20XX-XX-XXTXX:XX:XX.XXXXXX #XXXXXX]  INFO -- : [ws:2680] slack hello
+I, [20XX-XX-XXTXX:XX:XX.XXXXXX #XXXXXX]  INFO -- : [ws:2680] active connection count: 4
+I, [20XX-XX-XXTXX:XX:XX.XXXXXX #XXXXXX]  INFO -- : [ws:2680] slack events_api (event_callback)
+I, [20XX-XX-XXTXX:XX:XX.XXXXXX #XXXXXX]  INFO -- : [ws:2680] slack events_api (event_callback)
+I, [20XX-XX-XXTXX:XX:XX.XXXXXX #XXXXXX]  INFO -- : [ws:2680] slack events_api (event_callback)
+...
+```
+
+## API
+
+### `SlackSocketModeBot.new(token:, app_token:, logger:)`
+
+Connects to Slack with Socket Mode.
+
+* `token`: Slack's Bot User OAuth token (starting with `xoxb-`)
+* `app_token`: Slack's App-Level token (starting with `xapp-`)
+* `logger`: A Logger instance (optional)
+* block: Handles events received from Slack
+
+### `SlackSocketModeBot#call(method, data, token:)`
+
+Calls Slack's [Web API](https://api.slack.com/methods), such as [chat.postMessage](https://api.slack.com/methods/chat.postMessage).
+
+* `method`: API name (such as `"chat.postMessage"`)
+* `data`: Arguments
+
+This method returns the response as a JSON data.
+
+### `SlackSocketModeBot#run`
+
+Starts the main loop of communication with Slack. This method does not return.
+
+### `SlackSocketModeBot#step`
+
+Proceeds with the communication one step.
+
+This method returns an array of IO waiting to be readable and an array of IO waiting to be writable.
+They are supposed to be passed to `IO.select`.
+
+Typically, this method should be used as follows.
+
+```ruby
+while true
+  read_ios, write_ios = app.step
+  IO.select(read_ios, write_ios)
+end
+```
+
+This method allows you to manage the main loop yourself.
+If you don't need it, you can just use `SlackSocketModeBot#run`.

data/Rakefile

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+task default: %i[]

data/lib/slack_socket_mode_bot/simple_web_socket.rb

@@ -0,0 +1,114 @@
+class SlackSocketModeBot::SimpleWebSocket
+  def initialize(url)
+    uri = URI.parse(url)
+
+    unless uri.scheme == "https" || uri.scheme == "wss"
+      raise "unexpected scheme (not secure?): #{ uri.scheme }"
+    end
+
+    ctx = OpenSSL::SSL::SSLContext.new
+    ctx.ssl_version = "SSLv23"
+    ctx.verify_mode = OpenSSL::SSL::VERIFY_PEER
+    ctx.cert_store = OpenSSL::X509::Store.new
+    ctx.cert_store.set_default_paths
+
+    count = 0
+    begin
+      io = TCPSocket.new(uri.host, uri.port || 443)
+      @io = OpenSSL::SSL::SSLSocket.new(io, ctx)
+      @io.connect
+    rescue Socket::ResolutionError
+      sleep 1
+      count += 1
+      retry if count < 3
+      raise
+    end
+
+    @version = nil
+
+    @fib = Fiber.new do
+      closed = false
+      begin
+        handshake = WebSocket::Handshake::Client.new(url: url)
+        @write_buff = handshake.to_s.dup
+        handshake << Fiber.yield until handshake.finished?
+
+        @version = handshake.version
+        yield :open
+
+        frame = WebSocket::Frame::Incoming::Client.new
+        frame << handshake.leftovers
+        while true
+          while msg = frame.next
+            case msg.type
+            when :close
+              yield :close unless closed
+              closed = true
+            when :ping
+              send(msg.data, type: :pong)
+            when :pong
+            when :text
+              yield :message, msg.data, :text
+            when :binary
+              yield :message, msg.data, :binary
+            end
+          end
+          frame << Fiber.yield
+        end
+      rescue EOFError
+      ensure
+        yield :close unless closed
+        @io.close
+      end
+    end
+
+    @fib.resume
+  end
+
+  def send(data, type: :text, code: nil)
+    raise "not opened yet" unless @version
+    frame = WebSocket::Frame::Outgoing::Client.new(version: @version, data: data, type: type, code: code)
+    @write_buff << frame.to_s
+  end
+
+  def close(code: 1000, reason: "")
+    send(reason, type: :close, code: code) unless @io.closed?
+  end
+
+  def step(read_ios, write_ios)
+    wait_readable = wait_writable = false
+
+    unless @write_buff.empty?
+      len = @io.write_nonblock(@write_buff, exception: false)
+      case len
+      when :wait_readable then wait_readable = true
+      when :wait_writable then wait_writable = true
+      else
+        @write_buff.clear
+      end
+    end
+
+    while true
+      read_buff = @io.read_nonblock(4096, exception: false)
+      case read_buff
+      when :wait_readable then wait_readable = true; break
+      when :wait_writable then wait_writable = true; break
+      when nil
+        raise Errno::EPIPE
+      else
+        @fib.resume(read_buff)
+      end
+    end
+
+    read_ios << @io if wait_readable
+    write_ios << @io if wait_writable
+    return true
+
+  rescue Errno::EPIPE, Errno::ECONNRESET
+    begin
+      @fib.raise(EOFError)
+    rescue FiberError
+    end
+    return false
+  end
+end

data/lib/slack_socket_mode_bot/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+class SlackSocketModeBot
+  VERSION = "0.9.0"
+end

data/lib/slack_socket_mode_bot.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+require "uri"
+require "net/http"
+require "openssl"
+require "websocket"
+require "json"
+
+require_relative "slack_socket_mode_bot/version"
+require_relative "slack_socket_mode_bot/simple_web_socket"
+
+class SlackSocketModeBot
+  class Error < StandardError; end
+
+  #: (token: String, ?app_token: String, ?num_of_connections: Integer, ?debug: boolean, ?logger: Logger) { (untyped) -> untyped } -> void
+  def initialize(token:, app_token: nil, num_of_connections: 4, debug: false, logger: nil, &callback)
+    @token = token
+    @app_token = app_token
+    @conns = []
+    @debug = debug
+    @logger = logger
+    num_of_connections.times { add_connection(callback) } if app_token
+  end
+
+  #: (String method, untyped data, ?token: String) -> untyped
+  def call(method, data, token: @token)
+    count = 0
+    begin
+      url = URI("https://slack.com/api/" + method)
+      res = Net::HTTP.post(
+        url, JSON.generate(data),
+        "Content-type" => "application/json; charset=utf-8",
+        "Authorization" => "Bearer " + token,
+      )
+      json = JSON.parse(res.body, symbolize_names: true)
+      raise Error, json[:error] unless json[:ok]
+      json
+    rescue Socket::ResolutionError
+      sleep 1
+      count += 1
+      retry if count < 3
+      raise
+    end
+  end
+
+  private def add_connection(callback)
+    json = call("apps.connections.open", {}, token: @app_token)
+
+    url = json[:url]
+    url += "&debug_reconnects=true" if @debug
+    ws = SimpleWebSocket.new(url) do |type, data|
+      case type
+      when :open
+        @logger.info("[ws:#{ ws.object_id }] websocket open") if @logger
+      when :close
+        @logger.info("[ws:#{ ws.object_id }] websocket closed") if @logger
+        add_connection(callback)
+      when :message
+        begin
+          json = JSON.parse(data, symbolize_names: true)
+        rescue JSON::ParserError
+          add_connection(callback)
+          next
+        end
+
+        if @logger
+          @logger.debug("[ws:#{ ws.object_id }] slack message: #{ JSON.generate(json) }")
+          msg = "slack #{ json[:type] }"
+          payload_type = json.dig(:payload, :type)
+          msg += " (#{ payload_type })" if payload_type
+          @logger.info("[ws:#{ ws.object_id }] " + msg)
+        end
+
+        case json[:type]
+        when "hello"
+          @logger.info("[ws:#{ ws.object_id }] active connection count: #{ @conns.size }") if @logger
+        when "disconnect"
+          ws.close
+        else
+          response = { envelope_id: json[:envelope_id] }
+          if json[:accepts_response_payload]
+            response[:payload] = callback.call(json)
+          else
+            callback.call(json)
+          end
+          ws.send(JSON.generate(response))
+        end
+      end
+    end
+
+    @conns << ws
+  end
+
+  #: -> [Array[IO], Array[IO]]
+  def step
+    read_ios, write_ios = [], []
+    @conns.select! {|ws| ws.step(read_ios, write_ios) }
+    return read_ios, write_ios
+  end
+
+  #: -> bot
+  def run
+    while true
+      read_ios, write_ios = step
+      IO.select(read_ios, write_ios)
+    end
+  end
+end

data/sig/slack_socket_mode.rbs

@@ -0,0 +1,13 @@
+module Slack
+  class SocketMode
+    VERSION: String
+  
+    def initialize: (token: String, ?app_token: String, ?num_of_connections: Integer, ?debug: boolean, ?logger: Logger) { (untyped) -> untyped } -> void
+  
+    def call: (String method, untyped data, ?token: String) -> untyped
+  
+    def step: -> [Array[IO], Array[IO]]
+  
+    def run: -> bot
+  end
+end

metadata

@@ -0,0 +1,60 @@
+--- !ruby/object:Gem::Specification
+name: slack_socket_mode_bot
+version: !ruby/object:Gem::Version
+  version: 0.9.0
+platform: ruby
+authors:
+- Yusuke Endoh
+bindir: bin
+cert_chain: []
+date: 2024-06-21 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: websocket
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+email:
+- mame@ruby-lang.org
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- Rakefile
+- lib/slack_socket_mode_bot.rb
+- lib/slack_socket_mode_bot/simple_web_socket.rb
+- lib/slack_socket_mode_bot/version.rb
+- sig/slack_socket_mode.rbs
+homepage: https://github.com/mame/slack_socket_mode_bot
+licenses: []
+metadata:
+  homepage_uri: https://github.com/mame/slack_socket_mode_bot
+  source_code_uri: https://github.com/mame/slack_socket_mode_bot
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.0.dev
+specification_version: 4
+summary: A simple wrapper library for Slack's Socket Mode API
+test_files: []