mos-eisley-lambda 0.4.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: a229b8d14271b6bf7882e8d8484fafa898e802a5deb4c91e3f9c39770d2331a5
+  data.tar.gz: c9095d2f7bae1afcf598d2339f7bae922eac62eef1dba562953d0a625ab3a735
+SHA512:
+  metadata.gz: '048d9d0fab4a2a2e0a9dcc5dc5b5d22ad57b1c1566821b984ec2a93f14ba28ace529af47f7a3117004a0504d91f90c68f4b3c42af44c7b8f0343e2e0d241a7ab'
+  data.tar.gz: 0d826f2055702e1dd1f79378c6fe823337c88605c19e51edef64271359b51540bba150de6920d443d8e46ba1119d4722c9c312a7dc90bf8b53f656cf755afda9

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021 Ken J.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/Makefile

@@ -0,0 +1,15 @@
+all: build package
+
+build:
+	gem i mos-eisley-lambda -Ni ruby/gems/2.7.0
+	ls -m ruby/gems/2.7.0/gems
+
+package:
+	zip -r lambda-layers ruby -x ".*" -x "*/.*" -x "Makefile"
+	zipinfo -t lambda-layers
+
+clean:
+	rm -Rfv "ruby"
+
+cleanall: clean
+	rm -fv lambda-layers.zip

data/README.md

@@ -0,0 +1,136 @@
+# mos-eisley-lambda
+
+[![Gem Version](https://badge.fury.io/rb/mos-eisley-lambda.svg)](http://badge.fury.io/rb/mos-eisley-lambda) 
+
+“You will never find a more wretched hive of scum and villainy.” – Obi-Wan Kenobi
+
+Episode 2 of the Ruby based [Slack app](https://api.slack.com/) framework, this time for [AWS Lambda](https://aws.amazon.com/lambda/). Pure ruby, no external dependency.
+
+## Setup
+
+### AWS
+
+1. Create an SQS queue for MosEisley
+1. Create an IAM role for MosEisley Lambda function
+1. Create a Lambda function for MosEisley
+  - You can install this gem using [Lambda Layer](#mos-eisley-lambda) or just copy the `lib` directory to your Lambda code.
+1. Create an HTTP API Gateway
+  1. Create the appropriate routes (or use [the OpenAPI spec](https://github.com/kenjij/mos-eisley-lambda/blob/main/openapi3.yaml))
+  1. Create Lambda integration and attach it to all the routes
+
+Configure Lambda environment variable.
+
+- `SLACK_SIGNING_SECRET`: your Slack app credentials
+- `SLACK_BOT_ACCESS_TOKEN`: your Slack app OAuth token
+- `MOSEISLEY_SQS_URL`: AWS SQS URL used for the event pipeline
+- `MOSEISLEY_LOG_LEVEL` – optional, could be `DEBUG`, `INFO`, `WARN`, or `ERROR` 
+
+Configure Lambda code in your `lambda_function.rb` file.
+
+```ruby
+require 'mos-eisley-lambda'
+# Or, you can just copy the `lib` directory to your Lambda and...
+# require_relative './lib/mos-eisley-lambda'
+
+MosEisley::Handler.import
+# Or, if you store your handlers in a non-default location, dictate by...
+# MosEisley::Handler.import_from_path('./my-handlers')
+
+def lambda_handler(event:, context:)
+  MosEisley::lambda_event(event)
+end
+```
+
+### Slack
+
+Create a Slack app and configure the following.
+
+- **Interactivity & Shortcuts** – Request URL should be set to the `/actions` endpoint and Options Load URL should be set to the `/menus` endpoint.
+- **Slash Commands** – Request URL should be set to the `/commands` endpoint.
+- **OAuth & Permissions** – This is where you get the OAuth Tokens and set Scopes.
+- **Event Subscriptions** – Request URL should be set to the `/events` endpoint. You'll likely Subscribe to bot events `app_mention` at a minimum.
+
+### Handlers
+
+Create your own Mos Eisley handlers as blocks and register them. By default, store these Ruby files in the `handlers` directory.
+
+`ME::Handler.command_acks` holds `[Hash<String, Hash>]` which are Slack command keyword and response pair. The response is sent as-is back to Slack as an [immediate response](https://api.slack.com/interactivity/slash-commands#responding_immediate_response).
+
+```ruby
+ME::Handler.command_acks.merge!({
+  '/command' => {
+    response_type: 'in_channel',
+    text: '_Working on it…_',
+  },
+  '/secret' => {
+    response_type: 'ephemeral',
+    text: '_Just for you…_',
+  },
+})
+```
+
+Add handlers to process the Slack event.
+
+```ruby
+ME::Handler.add(:command, 'A Slack command') do |event, myself|
+  next unless event[:command] == '/command'
+  myself.stop
+  txt = "Your wish is my command."
+  payload = {
+    response_type: 'ephemeral',
+    text: txt,
+    blocks: [ME::S3PO::BlockKit.sec_text(txt)],
+  }
+  ME::SlackWeb.post_response_url(event[:response_url], payload)
+end
+```
+
+## Protocols
+
+### SQS
+
+- Attributes
+  - `source`: `slack`, `moseisley`, or other
+    - `endpoint`: if source is `slack`, which endpoint it arrived at
+  - `destination`: `slack` or `moseisley`
+    - `api`: if destination is `slack`
+- Message (JSON)
+  - `params`: object, meant to be passed to Slack API 
+  - `payload`: the data/payload itself
+
+### Helpers
+
+`ME::S3PO` – collection of helpers to analyze/create Slack messages.
+`ME::SlackWeb` – methods for sending payloads to Slack Web API calls.
+
+## Event Lifecycle
+
+### Inbound
+
+1. Slack event is sent to Mos Eisley Lambda function via API Gateway
+1. Slack event is verified and returned with parsed object
+1. If it's a slash command, MosEisley::Handler.command_acks is referenced and immediate response is sent
+1. The original Slack event JSON is sent to SQS with attributes
+
+### Event Processing
+
+1. Slack event is recieved by SQS trigger
+1. Handlers are called and processed according to original endpoint the event was sent to; actions, commands, events, menus
+1. Should send a Slack message to complete the event cycle
+
+<!-- ### Message Publishing
+
+Send a message to SQS from another app to send a Slack message
+
+1. Create a Slack message packaged to be sent to the API and send to SQS
+1. Message event is recieved by SQS trigger
+1. Message is sent to Slack API -->
+
+## Using with Lambda Layers
+
+Used the Makefile to create a zip file which can be uploaded as a Lambda Layer.
+
+```sh
+make
+# Installs the gem to './ruby' then archives it to 'lambda-layers.zip'
+```

data/lib/handler.rb

@@ -0,0 +1,95 @@
+module MosEisley
+  def self.handlers
+    MosEisley::Handler.handlers
+  end
+
+  class Handler
+    # Import handlers from designated directory
+    def self.import
+      path = File.expand_path('./handlers')
+      import_from_path(path)
+    end
+
+    # Import handlers from a directory
+    # @param path [String] directory name
+    def self.import_from_path(path)
+      Dir.chdir(path) {
+        Dir.foreach('.') { |f| load f unless File.directory?(f) }
+      }
+    end
+
+    # Call as often as necessary to add handlers with blocks; each call creates a MosEisley::Handler object
+    # @param type [Symbol] :action | :command | :event | :menu
+    # @param name [String]
+    def self.add(type, name = nil, &block)
+      @handlers ||= {
+        action: [],
+        command: [],
+        event: [],
+        menu: [],
+      }
+      @handlers[type] << MosEisley::Handler.new(type, name, &block)
+      MosEisley.logger.debug("Added #{type} handler: #{@handlers[type].last}")
+    end
+
+    # Example: {'/command' => {response_type: 'ephemeral', text: nil}}
+    # @return [Hash<String, Hash>] commands to acknowledge
+    def self.command_acks
+      @command_acks ||= {}
+    end
+
+    # @return [Hash<Symbol, Array>] containing all the handlers
+    def self.handlers
+      @handlers
+    end
+
+    # Run the handlers, typically called by the server
+    # @param event [Hash] from Slack Events API JSON data
+    def self.run(type, event)
+      logger = MosEisley.logger
+      response = nil
+      @handlers[type].each do |h|
+        response = h.run(event)
+        if h.stopped?
+          logger.debug('Handler stop was requested.')
+          break
+        end
+      end
+      logger.info("Done running #{type} handlers.")
+      response
+    end
+
+    attr_reader :type, :name
+
+    def initialize(t, n = nil, &block)
+      @type = t
+      @name = n
+      @block = block
+      @stopped = false
+    end
+
+    def run(event)
+      logger = MosEisley.logger
+      logger.warn("No block to execute for #{@type} handler: #{self}") unless @block
+      logger.debug("Running #{@type} handler: #{self}")
+      @stopped = false
+      @block.call(event, self)
+    rescue => e
+      logger.error(e.message)
+      logger.error(e.backtrace.join("\n"))
+      {text: "Woops, encountered an error."}
+    end
+
+    def stop
+      @stopped = true
+    end
+
+    def stopped?
+      @stopped
+    end
+
+    def to_s
+      "#<#{self.class}:#{self.object_id.to_s(16)}(#{name})>"
+    end
+  end
+end

data/lib/logger.rb

@@ -0,0 +1,11 @@
+require 'logger'
+
+module MosEisley
+  def self.logger=(logger)
+    @logger = logger
+  end
+
+  def self.logger
+    @logger ||= Logger.new($stdout, formatter: proc { |s, d, n, m| "#{s} : #{m}\n" })
+  end
+end

data/lib/mos-eisley-lambda.rb

@@ -0,0 +1,145 @@
+require_relative './logger'
+require_relative './slack'
+require_relative './s3po/s3po'
+require_relative './handler'
+require 'aws-sdk-sqs'
+require 'base64'
+require 'json'
+
+ME = MosEisley
+SQS = Aws::SQS::Client.new
+
+module MosEisley
+  def self.lambda_event(event)
+    abort unless preflightcheck
+    # Inbound Slack event (via API GW)
+    if event['routeKey']
+      MosEisley.logger.info('API GW event')
+      return apigw_event(event)
+    end
+    # Internal event (via SQS)
+    if event.dig('Records',0,'eventSource') == 'aws:sqs'
+      MosEisley.logger.info('SQS event')
+      return sqs_event(event)
+    end
+  end
+
+  def self.preflightcheck
+    l = ENV['MOSEISLEY_LOG_LEVEL']
+    if String === l && ['DEBUG', 'INFO', 'WARN', 'ERROR'].include?(l.upcase)
+      MosEisley.logger.level = eval("Logger::#{l.upcase}")
+    end
+    env_required = [
+      'MOSEISLEY_SQS_URL',
+      'SLACK_SIGNING_SECRET',
+      'SLACK_BOT_ACCESS_TOKEN',
+    ]
+    env_optional = [
+      'MOSEISLEY_LOG_LEVEL',
+    ]
+    env_required.each do |e|
+      if ENV[e].nil?
+        MosEisley.logger.error("Missing environment variable: #{e}")
+        return false
+      end
+    end
+    return true
+  end
+
+  def self.apigw_event(event)
+    se = ME::SlackEvent.validate(event)
+    unless se[:valid?]
+      MosEisley.logger.warn("#{se[:msg]}")
+      return {statusCode: 401}
+    end
+    resp = {statusCode: 200}
+    ep = event['routeKey'].split[-1]
+    MosEisley.logger.debug("Inbound Slack request to: #{ep}")
+    case ep
+    when '/actions'
+      # Nothing to do, just pass to SQS
+    when '/commands'
+      ser = {}
+      ack = ME::Handler.command_acks[se[:event][:command]]
+      if ack
+        ser[:response_type] = ack[:response_type]
+        ser[:text] =
+          if ack[:text]
+            ack[:text]
+          else
+            text = sep[:text].empty? ? '' : " #{se[:event][:text]}"
+            "Received: `#{se[:event][:command]}#{text}`"
+          end
+        # AWS sets status code and headers by passing JSON string
+        resp = JSON.fast_generate(ser)
+      end
+    when '/events'
+      # Respond to Slack challenge request
+      if se[:event][:url_verification]
+        c = se[:event][:challenge]
+        MosEisley.logger.info("Slack Events API challenge accepted: #{c}")
+        return "{\"challenge\": \"#{c}\"}"
+      end
+    when '/menus'
+      # ME::Handler.run(:menu, se)
+      # TODO to be implemented
+      return "{\"options\": []}"
+    else
+      MosEisley.logger.warn('Unknown request, ignored.')
+      return {statusCode: 400}
+    end
+    m = {
+      queue_url: ENV['MOSEISLEY_SQS_URL'],
+      message_attributes: {
+        'source' => {
+          data_type: 'String',
+          string_value: 'slack',
+        },
+        'destination' => {
+          data_type: 'String',
+          string_value: 'moseisley',
+        },
+        'endpoint' => {
+          data_type: 'String',
+          string_value: ep,
+        },
+      },
+      message_body: "{\"payload\":#{se[:json]}}",
+    }
+    SQS.send_message(m)
+    s = m[:message_body].length
+    MosEisley.logger.debug("Sent message to SQS with body size #{s}.")
+    return resp
+  end
+
+  def self.sqs_event(event)
+    a = event.dig('Records',0,'messageAttributes')
+    src = a.dig('source','stringValue')
+    dst = a.dig('destination','stringValue')
+    ep = a.dig('endpoint','stringValue')
+    se = JSON.parse(event.dig('Records',0,'body'), {symbolize_names: true})
+    se = se[:payload]
+    MosEisley.logger.debug("Event src: #{src}, dst: #{dst}")
+    if src == 'slack'
+      # Inbound Slack event
+      case ep
+      when '/actions'
+        ME::Handler.run(:action, se)
+      when '/commands'
+        ME::Handler.run(:command, se)
+      when '/events'
+        ME::Handler.run(:event, se)
+      when '/menus'
+        MosEisley.logger.warn('Menu request cannot be processed here.')
+      else
+        MosEisley.logger.warn("Unknown request: #{ep}")
+      end
+    elsif dst == 'slack'
+      # An event to be sent to Slack
+      MosEisley.logger.debug a.dig('api','stringValue')
+    else
+      MosEisley.logger.warn('Unknown event, ignored.')
+    end
+    return 0
+  end
+end

data/lib/neko-http.rb

@@ -0,0 +1,204 @@
+# NekoHTTP - Pure Ruby HTTP client using net/http
+# 
+# v.20200629
+
+require 'json'
+require 'logger'
+require 'net/http'
+require 'openssl'
+
+module Neko
+  def self.logger=(logger)
+    @logger = logger
+  end
+
+  def self.logger
+    @logger ||= NullLogger.new()
+  end
+
+  class HTTP
+    METHOD_HTTP_CLASS = {
+      get: Net::HTTP::Get,
+      put: Net::HTTP::Put,
+      patch: Net::HTTP::Patch,
+      post: Net::HTTP::Post,
+      delete: Net::HTTP::Delete
+    }
+
+    def self.get(url, params, hdrs = nil)
+      h = HTTP.new(url, hdrs)
+      data = h.get(params: params)
+      h.close
+      return data
+    end
+
+    def self.post_form(url, params, hdrs = nil)
+      h = HTTP.new(url, hdrs)
+      data = h.post(params: params)
+      h.close
+      return data
+    end
+
+    # Send POST request with JSON body
+    # It will set the Content-Type to application/json.
+    # @param url [String] full URL string
+    # @param obj [Array, Hash, String] Array/Hash will be converted to JSON
+    # @param hdrs [Array, Hash, String] Array/Hash will be converted to JSON
+    def self.post_json(url, obj, hdrs = {})
+      hdrs['Content-Type'] = 'application/json'
+      h = HTTP.new(url, hdrs)
+      case obj
+      when Array, Hash
+        body = JSON.fast_generate(obj)
+      when String
+        body = obj
+      else
+        raise ArgumentError, 'Argument is neither Array, Hash, String'
+      end
+      data = h.post(body: body)
+      h.close
+      return data
+    end
+
+    attr_reader :init_uri, :http
+    attr_accessor :logger, :headers
+
+    def initialize(url, hdrs = nil)
+      @logger = Neko.logger
+      @init_uri = URI(url)
+      raise ArgumentError, 'Invalid URL' unless @init_uri.class <= URI::HTTP
+      @http = Net::HTTP.new(init_uri.host, init_uri.port)
+      http.use_ssl = init_uri.scheme == 'https'
+      http.verify_mode = OpenSSL::SSL::VERIFY_PEER
+      @headers = hdrs
+    end
+
+    def get(path: nil, params: nil, query: nil)
+      return operate(__method__, path: path, params: params, query: query)
+    end
+
+    def post(path: nil, params: nil, body: nil, query: nil)
+      return operate(__method__, path: path, params: params, body: body, query: query)
+    end
+
+    def put(path: nil, params: nil, body: nil, query: nil)
+      return operate(__method__, path: path, params: params, body: body, query: query)
+    end
+
+    def patch(path: nil, params: nil, body: nil, query: nil)
+      return operate(__method__, path: path, params: params, body: body, query: query)
+    end
+
+    def delete(path: nil, params: nil, query: nil)
+      return operate(__method__, path: path, params: params, query: query)
+    end
+
+    def close
+      http.finish if http.started?
+    end
+
+    private
+
+    def operate(method, path: nil, params: nil, body: nil, query: nil)
+      uri = uri_with_path(path)
+      case method
+      when :get, :delete
+        if params
+          query = URI.encode_www_form(params)
+          logger.info('Created urlencoded query from params')
+        end
+        uri.query = query if query
+        req = METHOD_HTTP_CLASS[method].new(uri)
+      when :put, :patch, :post
+        uri.query = query if query
+        req = METHOD_HTTP_CLASS[method].new(uri)
+        if params
+          req.form_data = params
+          logger.info('Created form data from params')
+        elsif body
+          req.body = body
+        end
+      else
+        return nil
+      end
+      if uri.userinfo
+        req.basic_auth(uri.user, uri.password)
+        logger.info('Created basic auth header from URL')
+      end
+      data = send(req)
+      data = redirect(method, uri: data, body: req.body) if data.class <= URI::HTTP
+      return data
+    end
+
+    def uri_with_path(path)
+      uri = init_uri.clone
+      uri.path = path unless path.nil?
+      return uri
+    end
+
+    def send(req)
+      inject_headers_to(req)
+      unless http.started?
+        logger.info('HTTP session not started; starting now')
+        http.start
+        logger.debug("Opened connection to #{http.address}:#{http.port}")
+      end
+      logger.debug("Sending HTTP #{req.method} request to #{req.path}")
+      logger.debug("Body size: #{req.body.length}") if req.request_body_permitted?
+      res = http.request(req)
+      return handle_response(res)
+    end
+
+    def inject_headers_to(req)
+      return if headers.nil?
+      headers.each { |k, v| req[k] = v }
+      logger.info('Header injected into HTTP request header')
+    end
+
+    def handle_response(res)
+      if res.connection_close?
+        logger.info('HTTP response header says connection close; closing session now')
+        close
+      end
+      case res
+      when Net::HTTPRedirection
+        logger.info('HTTP response was a redirect')
+        data = URI(res['Location'])
+        if data.class == URI::Generic
+          data = uri_with_path(res['Location'])
+          logger.debug("Full URI object built for local redirect with path: #{data.path}")
+        end
+      # when Net::HTTPSuccess
+      # when Net::HTTPClientError
+      # when Net::HTTPServerError
+      else
+        data = {
+          code: res.code.to_i,
+          headers: res.to_hash,
+          body: res.body,
+          message: res.msg
+        }
+      end
+      return data
+    end
+
+    def redirect(method, uri:, body: nil)
+      if uri.host == init_uri.host && uri.port == init_uri.port
+        logger.info("Local #{method.upcase} redirect, reusing HTTP session")
+        new_http = self
+      else
+        logger.info("External #{method.upcase} redirect, spawning new HTTP object")
+        new_http = HTTP.new("#{uri.scheme}://#{uri.host}#{uri.path}", headers)
+      end
+      new_http.__send__(:operate, method, path: uri.path, body: body, query: uri.query)
+    end
+  end
+
+  class NullLogger < Logger
+    def initialize(*args)
+    end
+
+    def add(*args, &block)
+    end
+  end
+end

data/lib/s3po/blockkit.rb

@@ -0,0 +1,56 @@
+module MosEisley
+  module S3PO
+    module BlockKit
+      # @param txt [String]
+      # @param type [Symbol] :plain | :emoji | :mrkdwn
+      # @return [Hash] Block Kit section object
+      def self.sec_text(txt, type = :mrkdwn)
+        {
+          type: :section,
+          text: text(txt, type),
+        }
+      end
+
+      # @param txt [String]
+      # @param type [Symbol] :plain | :emoji | :mrkdwn
+      # @return [Hash] Block Kit text object
+      def self.text(txt, type = :mrkdwn)
+        obj = {text: txt}
+        case type
+        when :mrkdwn
+          obj[:type] = type
+        when :emoji
+          obj[:emoji] = true
+        else
+          obj[:emoji] = false
+        end
+        obj[:type] ||= :plain_text
+        obj
+      end
+
+      # @param txt [String]
+      # @return [Hash] Block Kit plain_text object with emoji:false
+      def self.plain_text(txt)
+        text(txt, :plain)
+      end
+
+      # @param txt [String]
+      # @return [Hash] Block Kit plain_text object with emoji:true
+      def self.emoji_text(txt)
+        text(txt, :emoji)
+      end
+
+      # @param value [String] string that will be passed to the app when selected
+      # @param txt [String]
+      # @param type [Symbol] :plain_text | :emoji | :mrkdwn
+      # @return [Hash] Block Kit option object
+      def self.option(value, txt, type = :mrkdwn)
+        t = MosEisley::S3PO::BlockKit.text(txt, type)
+        {
+          text: t,
+          value: value,
+        }
+      end
+    end
+  end
+end

data/lib/s3po/s3po.rb

@@ -0,0 +1,108 @@
+require 'json'
+require 'time'
+require_relative './blockkit'
+
+module MosEisley
+  module S3PO
+    def self.parse_json(json)
+      return JSON.parse(json, {symbolize_names: true})
+    rescue => e
+      MosEisley.logger.warn("JSON parse error: #{e}")
+      return nil
+    end
+
+    # Convert object into JSON, optionally pretty-format
+    # @param obj [Object] any Ruby object
+    # @param opts [Hash] any JSON options
+    # @return [String] JSON string
+    def self.json_with_object(obj, pretty: false, opts: nil)
+      return '{}' if obj.nil?
+      if pretty
+        opts = {
+          indent: '  ',
+          space: ' ',
+          object_nl: "\n",
+          array_nl: "\n"
+        }
+      end
+      JSON.fast_generate(MosEisley::S3PO.format_json_value(obj), opts)
+    end
+
+    # Return Ruby object/value to JSON standard format
+    # @param val [Object]
+    # @return [Object]
+    def self.format_json_value(val)
+      s3po = MosEisley::S3PO
+      case val
+      when Array
+        val.map { |v| s3po.format_json_value(v) }
+      when Hash
+        val.reduce({}) { |h, (k, v)| h.merge({k => s3po.format_json_value(v)}) }
+      when String
+        val.encode('UTF-8', {invalid: :replace, undef: :replace})
+      when Time
+        val.utc.iso8601
+      else
+        val
+      end
+    end
+
+    def self.create_event(e, my_id: nil, type: nil)
+      type ||= e[:type] if e[:type]
+      case type
+      when 'message', 'app_mention'
+        return Message.new(e, my_id)
+      when :action
+        return Action.new(e)
+      else
+        return GenericEvent.new(e)
+      end
+    end
+
+    # Escape string with basic Slack rules; no command encoding is done as it often requires more information than provided in the text
+    # @param text [String] string to escape
+    # @return [String] escaped text
+    def self.escape_text(text)
+      esced = String.new(text)
+      esced.gsub!('&', '&')
+      esced.gsub!('<', '&lt;')
+      esced.gsub!('>', '&gt;')
+      return esced
+    end
+
+    # Return plain text parsing Slack escapes and commands
+    # @param text [String] string to decode
+    # @return [String] plain text
+    def self.decode_text(text)
+      plain = String.new(text)
+      # keep just the labels
+      plain.gsub!(/<([#@]*)[^>|]*\|([^>]*)>/, '<\1\2>')
+      # process commands
+      plain.gsub!(/<!(everyone|channel|here)>/, '<@\1>')
+      plain.gsub!(/<!(.*?)>/, '<\1>')
+      # remove brackets
+      plain.gsub!(/<(.*?)>/, '\1')
+      # unescape
+      plain.gsub!('&gt;', '>')
+      plain.gsub!('&lt;', '<')
+      plain.gsub!('&amp;', '&')
+      return plain
+    end
+
+    # Return text with basic visual formatting symbols removed;
+    #   it will remove all symbols regardless of syntax
+    # @param text [String] string to clean up
+    # @return [String] cleaned text
+    def self.remove_symbols(text)
+      text.delete('_*~`')
+    end
+
+    # Enclose Slack command in control characters
+    # @param cmd [String] command
+    # @param label [String] optional label
+    # @return [String] escaped command
+    def self.escape_command(cmd, label = nil)
+      "<#{cmd}" + (label ? "|#{label}" : '') + '>'
+    end
+  end
+end

data/lib/slack.rb

@@ -0,0 +1,143 @@
+require 'openssl'
+require 'time'
+require_relative './neko-http'
+
+module MosEisley
+  module SlackEvent
+    # Validate incoming Slack request, decodes the body then into JSON
+    # @param e [Hash] original AWS API GW event object
+    # @return [Hash] {valid?: [Bool], msg: [String], json: [String], event: [Hash]}
+    def self.validate(e)
+      t = e.dig('headers', 'x-slack-request-timestamp')
+      return {valid?: false, msg: 'Invalid request.'} if t.nil?
+      if (Time.new - Time.at(t.to_i)).abs > 300
+        return {valid?: false, msg: 'Request too old.'}
+      end
+      b = e['isBase64Encoded'] ? Base64.decode64(e['body']) : e['body']
+      s = "v0:#{t}:#{b}"
+      k = ENV['SLACK_SIGNING_SECRET']
+      sig = "v0=#{OpenSSL::HMAC.hexdigest('sha256', k, s)}"
+      if e.dig('headers', 'x-slack-signature') != sig
+        return {valid?: false, msg: 'Invalid signature.'}
+      end
+      b = SlackEvent.parse_http_body(b, e.dig('headers', 'content-type'))
+      h = JSON.parse(b, {symbolize_names: true})
+      {valid?: true, msg: 'Validated.', json: b, event: h}
+    end
+
+    def self.parse_http_body(b, t)
+      case t
+      when 'application/json'
+        b
+      when 'application/x-www-form-urlencoded'
+        JSON.fast_generate(URI.decode_www_form(b).to_h)
+      when 'application/xml'
+        require 'rexml/document'
+        REXML::Document.new(b)
+      else
+        b
+      end
+    end
+  end
+
+  module SlackWeb
+    BASE_URL = 'https://slack.com/api/'.freeze
+
+    def self.chat_memessage(channel:, text:)
+      data = {channel: channel, text: text}
+      post_to_slack('chat.meMessage', data)
+    end
+
+    def self.chat_postephemeral()
+    end
+
+    def self.chat_postmessage(channel:, blocks: nil, text: nil, thread_ts: nil)
+      data = {channel: channel}
+      if blocks
+        data[:blocks] = blocks
+        data[:text] = text if text
+      else
+        text ? data[:text] = text : raise
+      end
+      data[:thread_ts] = thread_ts if thread_ts
+      post_to_slack('chat.postMessage', data)
+    end
+
+    def self.chat_schedulemessage()
+    end
+
+    def self.post_response_url(url, payload)
+      post_to_slack(nil, payload, url)
+    end
+
+    def self.post_log(blocks: nil, text: nil)
+      if c = ENV['SLACK_LOG_CHANNEL_ID']
+        d = {channel: c}
+        if blocks
+          d[:blocks] = blocks
+          if text
+            d[:text] = text
+          end
+        else
+          if text
+            d[:text] = text
+          else
+            return nil
+          end
+        end
+        chat_postmessage(d)
+      else
+        return nil
+      end
+    end
+
+    def self.views_open(trigger_id:, view:)
+      data = {
+        trigger_id: trigger_id,
+        view: view,
+      }
+      post_to_slack('views.open', data)
+    end
+
+    def self.views_update(view_id:, view:, hash: nil)
+      data = {
+        view_id: view_id,
+        view: view,
+      }
+      data[:hash] if hash
+      post_to_slack('views.update', data)
+    end
+
+    def self.views_push(trigger_id:, view:)
+    end
+
+    # def self.auth_test
+    #   post_to_slack('auth.test')
+    # end
+
+    private
+
+    def self.post_to_slack(method, data, url = nil)
+      l = MosEisley.logger
+      url ||= BASE_URL + method
+      head = {authorization: "Bearer #{ENV['SLACK_BOT_ACCESS_TOKEN']}"}
+      r = Neko::HTTP.post_json(url, data, head)
+      if r[:code] != 200
+        l.warn("post_to_slack HTTP failed: #{r[:message]}")
+        return nil
+      end
+      begin
+        h = JSON.parse(r[:body], {symbolize_names: true})
+        if h[:ok]
+          return h
+        else
+          l.warn("post_to_slack Slack failed: #{h[:error]}")
+          l.debug("#{h[:response_metadata]}")
+          return nil
+        end
+      rescue
+        return {body: r[:body]}
+      end
+    end
+  end
+end

data/mos-eisley-lambda.gemspec

@@ -0,0 +1,15 @@
+Gem::Specification.new do |s|
+  s.name          = 'mos-eisley-lambda'
+  s.version       = '0.4.0'
+  s.authors       = ['Ken J.']
+  s.email         = ['kenjij@gmail.com']
+  s.summary       = %q{Ruby based Slack bot framework, for AWS Lambda use}
+  s.description   = %q{Ruby based Slack bot framework, for AWS Lambda use. Also provides helpers to analyze/build messages. Event based utilizing SQS.}
+  s.homepage      = 'https://github.com/kenjij/mos-eisley-lambda'
+  s.license       = 'MIT'
+
+  s.files         = `git ls-files`.split($/)
+  s.require_paths = ['lib']
+
+  s.required_ruby_version = '>= 2.7'
+end

data/openapi3.yaml

@@ -0,0 +1,27 @@
+openapi: "3.0.1"
+info:
+  title: "MosEisley"
+  description: "MosEisley API gateway"
+  version: "2020-01-01 00:00:00UTC"
+paths:
+  /events:
+    post:
+      responses:
+        default:
+          description: "Default response for POST /events"
+  /actions:
+    post:
+      responses:
+        default:
+          description: "Default response for POST /actions"
+  /menus:
+    post:
+      responses:
+        default:
+          description: "Default response for POST /menus"
+  /commands:
+    post:
+      responses:
+        default:
+          description: "Default response for POST /commands"
+x-amazon-apigateway-importexport-version: "1.0"

metadata

@@ -0,0 +1,56 @@
+--- !ruby/object:Gem::Specification
+name: mos-eisley-lambda
+version: !ruby/object:Gem::Version
+  version: 0.4.0
+platform: ruby
+authors:
+- Ken J.
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2021-07-26 00:00:00.000000000 Z
+dependencies: []
+description: Ruby based Slack bot framework, for AWS Lambda use. Also provides helpers
+  to analyze/build messages. Event based utilizing SQS.
+email:
+- kenjij@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- Makefile
+- README.md
+- lib/handler.rb
+- lib/logger.rb
+- lib/mos-eisley-lambda.rb
+- lib/neko-http.rb
+- lib/s3po/blockkit.rb
+- lib/s3po/s3po.rb
+- lib/slack.rb
+- mos-eisley-lambda.gemspec
+- openapi3.yaml
+homepage: https://github.com/kenjij/mos-eisley-lambda
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.7'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.2
+signing_key:
+specification_version: 4
+summary: Ruby based Slack bot framework, for AWS Lambda use
+test_files: []