rodbot 0.1.0

data/lib/rodbot/plugins/matrix/README.matrix.md

@@ -0,0 +1,42 @@
+# Rodbot Plugin – Matrix
+
+Relay with the Matrix communication network
+
+## Preparation
+
+To get an `access_token`, you have to create a new bot user. (Actually, Matrix does not know special bot users, just create a normal one instead.)
+
+1. Create a regular Matrix user account with [Element](https://app.element.io)
+2. In "All settings", set the display name, upload a user picture and disable all notifications. If the bot is supposed to join encrypted rooms as well, you should download the backup keys.
+3. You find the access token in "All settings -> Help & About".
+
+Invite this new bot user to the room of your choice and figure out the corresponding `room_id`. You can use the public room ID (e.g. `#myroom:matrix.org`) but since it may change you're better off using the internal room ID (e.g. `!kg7FkT64kGUgfk8R7a:matrix.org`) instead:
+
+1. Right click on the room in question and select "Settings"
+2. Click on "Advanced"
+
+## Activation
+
+Install the required gems via the corresponding Bundler group:
+
+```
+bundle config set --local with matrix
+bundle install
+```
+
+Then activate and configure this plugin in `config/rodbot.rb`:
+
+```ruby
+plugin :matrix do
+  access_token '<TOKEN>'
+  room_id '<ID>'
+end
+```
+
+You might want to use the credentials facilities of Rodbot to encrypt the token.
+
+## Usage
+
+Once Rodbot is restarted, the Matrix relay will automatically accept the invitation and start listening. To check whether the relay works fine, just say +!ping+ in the room, you should receive a "pong" in reply.
+
+Any room message beginning with "!" is considered a bot command.

data/lib/rodbot/plugins/matrix/relay.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+require 'matrix_sdk'
+
+using Rodbot::Refinements
+
+module Rodbot
+  class Plugins
+    class Matrix
+      class Relay < Rodbot::Relay
+        include Rodbot::Memoize
+
+        def loops
+          client.on_invite_event.add_handler { on_invite(_1) }
+          client.sync(filter: filter(empty: true))
+          client.on_event.add_handler('m.room.message') { on_message(_1) }
+          [method(:read_loop), method(:write_loop)]
+        end
+
+        private
+
+        def access_token
+          Rodbot.config(:plugin, :matrix, :access_token)
+        rescue => error
+          raise Rodbot::PluginError.new("invalid access_token", error.message)
+        end
+
+        def room_id
+          Rodbot.config(:plugin, :matrix, :room_id)
+        rescue => error
+          raise Rodbot::PluginError.new("invalid room_id", error.message)
+        end
+
+        def homeserver
+          room_id.split(':').last
+        rescue => error
+          raise Rodbot::PluginError.new("invalid room_id", error.message)
+        end
+
+        memoize def client
+          MatrixSdk::Client.new(homeserver, access_token: access_token, client_cache: :some)
+        end
+
+        memoize def room
+          client.ensure_room(room_id)
+        end
+
+        def read_loop
+          loop do
+            client.sync(filter: filter)
+          rescue StandardError
+            sleep 5
+          end
+        end
+
+        def write_loop
+          server = TCPServer.new(*bind)
+          loop do
+            Thread.start(server.accept) do |remote|
+              body = remote.gets("\x04")
+              remote.close
+              body.force_encoding('UTF-8')
+              room.send_html body.md_to_html
+            end
+          end
+        end
+
+        def on_invite(invite)
+          client.join_room(invite[:room_id]) if Rodbot.config(:plugin, :matrix, :room_id) == invite[:room_id]
+        end
+
+        def on_message(message)
+          if message.content[:msgtype] == 'm.text' && message.content[:body].start_with?('!')
+            html = 'pong' if message.content[:body] == '!ping'
+            html ||= reply_to(message)
+            room.send_html(html)
+          end
+        end
+
+        def reply_to(message)
+          command(*message.content[:body][1..].split(/\s+/, 2)).
+            md_to_html.
+            psub(placeholders(client.get_user(message.sender)))
+        end
+
+        def placeholders(sender)
+          {
+            sender: "https://matrix.to/#/#{sender.id}"
+          }
+        end
+
+        def filter(empty: false)
+          {
+            presence: { types: [] },
+            account_data: { types: [] },
+            room: {
+              ephemeral: { types: [] },
+              state: {
+                types: (empty ? [] : ['m.room.*']),
+                lazy_load_members: true
+              },
+              timeline: {
+                types: (empty ? [] : ['m.room.message'])
+              },
+              account_data: { types: [] }
+            }
+          }
+        end
+
+      end
+    end
+  end
+end

data/lib/rodbot/plugins/otp/README.otp.md

@@ -0,0 +1,82 @@
+# Rodbot Plugin – OTP
+
+Guard commands with one-time passwords
+
+## Preparation
+
+Create a secret key and add it to your authenticator app:
+
+```
+require 'rotp'
+ROTP::Base32.random
+```
+
+## Activation
+
+Activate and configure this plugin in `config/rodbot.rb` using the secret you've created in the previous section:
+
+```ruby
+plugin :otp do
+  secret '<SECRET>'
+  drift 10
+end
+```
+
+The `drift` config is optional. In this example, one-time passwords are accepted up to 10 seconds beyond their expiration to compensate for slow networks. By default, no drift is granted.
+
+## Usage
+
+To protect a command, just add a guard to the corresponding app route. Say, you have implemented a command `!reboot example.com` in `app/routes/reboot.rb`:
+
+```ruby
+module Routes
+  class Hello < App
+
+    route do |r|
+
+      # GET /reboot
+      r.root do |r|
+        response['Content-Type'] = 'text/plain; charset=utf-8'
+        ServerService.new(r.arguments).reboot!
+        'Done!'
+      end
+
+    end
+
+  end
+end
+```
+
+(As a reminder: Up until this point, `r.arguments` is a mere shortcut for `r.params['arguments']`.)
+
+In order to protect this rather dangerous command with a one-time password, you have to guard the route:
+
+```ruby
+r.root do |r|
+  r.halt [401, {}, ['Unauthorized']] unless r.valid_otp?
+  response['Content-Type'] = 'text/plain; charset=utf-8'
+  ServerService.new(r.arguments).reboot!
+  'Done!'
+end
+```
+
+To execute the command now, you have to add the six digit one-time password to the end of it:
+
+```
+!reboot example.com 123456
+```
+
+The `r.valid_otp?` guard extracts the one-time password from the message and validates it. In this example, a validation result `true` causes the server to be rebooted. Please note that `r.argument` after the guard does not contain the one-time password anymore!
+
+If halting with a 401 error is all you want, there's even a shorter alternative `r.require_valid_otp!`:
+
+```ruby
+r.root do |r|
+  r.require_valid_otp!
+  response['Content-Type'] = 'text/plain; charset=utf-8'
+  ServerService.new(r.arguments).reboot!
+  'Done!'
+end
+```
+
+This route does exactly the same as the more verbose one above.

data/lib/rodbot/plugins/otp/app.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require 'rotp'
+
+module Rodbot
+  class Plugins
+    class Otp
+      module App
+
+        module RequestMethods
+          include Rodbot::Memoize
+
+          def valid_otp?
+            return false unless password
+            return false if Rodbot.db.get(:otp, password)   # already used
+            valid = totp.verify(password, drift_behind: Rodbot.config(:otp, :drift).to_i)
+            !!if
+              Rodbot.db.set(:otp, password) { true }
+              true
+            end
+          end
+
+          def require_valid_otp!
+            halt [401, {}, ['Unauthorized']] unless valid_otp?
+          end
+
+          private
+
+          memoize def totp
+            secret =  Rodbot.config(:plugin, :otp, :secret)
+            fail(Rodbot::PluginError, "OTP secret is not set") unless secret
+            ROTP::TOTP.new(secret, issuer: 'Rodbot')
+          end
+
+          # Extract (and remove) the password from arguments
+          #
+          # @return [String, nil] extracted password if any
+          memoize def password
+            params['arguments'] = params['arguments']&.sub(/\s*(\d{6})\s*\z/, '')
+            $1
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/rodbot/plugins/word_of_the_day/README.word_of_the_day.md

@@ -0,0 +1,13 @@
+# Rodbot Plugin – Word of the Day
+
+Word of the day announcements
+
+## Setup
+
+Activate and configure this plugin in `config/rodbot.rb`:
+
+```ruby
+plugin :word_of_the_day do
+  time '10:00'
+end
+```

data/lib/rodbot/plugins/word_of_the_day/schedule.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require 'httparty'
+
+module Rodbot
+  class Plugins
+    class WordOfTheDay
+      class Schedule
+        def initialize
+          Clockwork.every(1.day, -> { Rodbot.say message }, at: time)
+        end
+
+        private
+
+        def time
+          Rodbot.config(:plugin, :word_of_the_day, :time) || '12:00'
+        end
+
+        def message
+          Rodbot::Plugins::WordOfTheDay::Today.new.message
+        end
+
+      end
+
+      class Today
+        def initialize
+          @response = HTTParty.get('https://www.merriam-webster.com/word-of-the-day')
+        end
+
+        def message
+          if @response.success?
+            "Word of the day: [#{word}](#{url})"
+          else
+            "Sorry, there was a problem fetching the word of the day."
+          end
+        end
+
+        private
+
+        def word
+          @response.body.match(/<h2 class="word-header-txt">(.+?)</).captures.first
+        end
+
+        def url
+          @response.body.match(/<meta property="og:url" content="(.+?)"/).captures.first
+        end
+      end
+
+    end
+  end
+end

data/lib/rodbot/plugins.rb

@@ -0,0 +1,81 @@
+# frozen-string-literal: true
+
+using Rodbot::Refinements
+
+module Rodbot
+
+  # Interface for bundled and gemified plugins
+  class Plugins
+
+    # Required service extensions from plugins
+    #
+    # @return [Hash] map from extension name (Symbol) to module or class
+    #   path (String)
+    attr_reader :extensions
+
+    def initialize
+      @extensions = {}
+    end
+
+    # Extend app service with app components provided by all active plugins
+    def extend_app
+      require_extensions(:app) do |name, path|
+        begin
+          ::App.run(name, "#{path}/routes".constantize)
+        rescue NameError
+        end
+        begin
+          Roda::RodaPlugins.register_plugin(name, path.constantize)
+        rescue NameError
+        end
+      end
+    end
+
+    # Extend relay service with relay components provided by all active plugins
+    def extend_relay
+      return if extensions.key? :relay
+      require_extensions(:relay)
+    end
+
+    # Extend schedule service with schedule components provided by all active
+    # plugins
+    def extend_schedule
+      return if extensions.key? :schedule
+      require_extensions(:schedule) do |name, path|
+        path.constantize.new
+      end
+    end
+
+    private
+
+    # Require (and log) the service extensions provided by all active plugins
+    #
+    # @param service [Symbol] any of {Rodbot::SERVICES}
+    # @yield additional code to execute after require
+    # @return [self]
+    def require_extensions(service)
+      Rodbot.config(:plugin).each_key do |name|
+        path = "rodbot/plugins/#{name}/#{service}"
+        if rescued_require(path)
+          Rodbot.log("#{path} required", level: Logger::DEBUG)
+          extensions[service] ||= {}
+          extensions[service][name] = path
+          yield(name, path) if block_given?
+        end
+      end
+      self
+    end
+
+    # Same as +require+ but never fail with +LoadError+
+    #
+    # @param path [String] path to require
+    # @return [Boolean] true if required (again) or false if load failed
+    def rescued_require(path)
+      require path
+      true
+    rescue LoadError
+      false
+    end
+
+  end
+end

data/lib/rodbot/rack.rb

@@ -0,0 +1,50 @@
+# frozen-string-literal: true
+
+require 'httparty'
+
+using Rodbot::Refinements
+
+module Rodbot
+  module Rack
+
+    class << self
+
+      # Default +config.ru+
+      #
+      # In case you wish to do things differently, just copy the contents of
+      # this method into your +config.ru+ file and tweak it.
+      def boot(rack)
+        loader = Zeitwerk::Loader.new
+        loader.logger = Rodbot::Log.logger('loader')
+        loader.push_dir(Rodbot.env.root.join('lib'))
+        loader.push_dir(Rodbot.env.root.join('app'))
+
+        if Rodbot.env.development? || Rodbot.env.test?
+          loader.enable_reloading
+          loader.setup
+          rack.run ->(env) do
+            loader.reload
+            App.call(env)
+          end
+        else
+          loader.setup
+          Zeitwerk::Loader.eager_load_all
+          rack.run App.freeze.app
+        end
+      end
+
+      # Send request to the app service
+      #
+      # @param path [String] path e.g. +/help+
+      # @param query [Hash] query hash e.g. +{ search: 'foobar' }+
+      # @param method [Symbol, String] HTTP method
+      # @param timeout [Integer] max seconds to wait for response
+      # @return [HTTParty::Response]
+      def request(path, query: {}, method: :get, timeout: 10)
+        HTTParty.send(method, Rodbot::Services::App.url.uri_concat(path), query: query, timeout: timeout)
+      end
+
+    end
+
+  end
+end

data/lib/rodbot/refinements.rb

@@ -0,0 +1,118 @@
+# frozen-string-literal: true
+
+require 'uri'
+require 'kramdown'
+
+module Rodbot
+  module Refinements
+
+    # @!method camelize
+    #   Convert from under_scores to CamelCase
+    #
+    #   @example
+    #     camelize('foo_bar')   # => 'FooBar'
+    #
+    #   @return [String] CamelCased string
+    refine String do
+      def camelize
+        Rodbot::Refinements.inflector.camelize(self, nil)
+      end
+    end
+
+    # @!method constantize
+    #   Convert module or class path to module or class
+    #
+    #   @example
+    #     'foo/bar_baz'.constantize   # => Foo::BarBaz
+    #
+    #   @return [Class, Module] class or module
+    refine String do
+      def constantize
+        Module.const_get(self.split('/').map(&:camelize).join('::'))
+      end
+    end
+
+    # @!method uri_concat
+    #   Safely concat path segments to a URI string
+    #
+    #   {URI#join} is ultimately used to add the given segments which has a
+    #   maybe counter-intuitive API at first. Check out the docs of {URI#join}
+    #   and the examples below.
+    #
+    #   @example
+    #     s = 'http://example.com'
+    #     s.uri_concat('foo')               # => "http://example.com/foo"
+    #     s.uri_concat('foo/')              # => "http://example.com/foo/"
+    #     s.uri_concat('foo', 'bar')        # => "http://example.com/bar"   <- sic!
+    #     s.uri_concat('foo/, 'bar')        # => "http://example.com/foo/bar"
+    #     s.uri_concat('foo/, 'bar.html')   # => "http://example.com/foo/bar.html"
+    #     s.uri_concat('föö')               # => "http://example.com/f%C3%B6%C3%B6"
+    #
+    #   @param segments [Array<String>] path segments
+    #   @return [String] concatted URI
+    refine String do
+      def uri_concat(*segments)
+        parser = URI::Parser.new
+        segments.inject(URI(self)) do |uri, segment|
+          uri + parser.escape(segment)
+        end.to_s
+      end
+    end
+
+    # @!method md_to_html
+    #   Converts Markdown in the string to HTML
+    #
+    #   @example
+    #     '**important**'.md_to_html   # => '<strong>important</strong>'
+    #
+    #   @return [String] HTML
+    refine String do
+      def md_to_html
+        Kramdown::Document.new(self, input: 'GFM').to_html.strip
+      end
+    end
+
+    # @!method html_to_text
+    #   Converts HTML to plain text by removing all tags
+    #
+    #   @example
+    #     '<strong>important</strong>'.html_to_text   # => 'important'
+    #
+    #   @return [String] text
+    refine String do
+      def html_to_text
+        self.gsub(/<.*?>/, '')
+      end
+    end
+
+    # @!method psub
+    #   Replace placeholders
+    #
+    #   Placeholders are all UPCASE and wrapped in [[ and ]]. They must match
+    #   keys in the placeholder hash, however, these keys are Symbols and all
+    #   downcase.
+    #
+    #   @example
+    #     placeholders = { sender: 'Oggy' }
+    #     'Hi, [[SENDER]]!'.psub(placeholders)   # => 'Hi, Oggy!'
+    #
+    #   @return [String] string without placeholders
+    refine String do
+      def psub(placeholders)
+        self.gsub(/\[\[.*?\]\]/) { placeholders[_1[2..-3].downcase.to_sym] }
+      end
+    end
+
+    class << self
+      include Rodbot::Memoize
+
+      # Reusable inflector instance
+      #
+      # @return [Zeitwerk::Inflector]
+      memoize def inflector
+        Zeitwerk::Inflector.new
+      end
+    end
+
+  end
+end

data/lib/rodbot/relay.rb

@@ -0,0 +1,104 @@
+# frozen-string-literal: true
+
+require 'digest'
+require 'socket'
+require 'httparty'
+
+module Rodbot
+
+  # Base class for relay extensions
+  class Relay
+    include Rodbot::Memoize
+
+    class << self
+
+      # Post a message via one or more relay services
+      #
+      # By default, messages are posted via all relay services which have
+      # "say true" configured in their corresponding config blocks. To further
+      # narrow it to exactly one relay service, use the +on+ argument.
+      #
+      # @param message [String] message to post
+      # @param on [Symbol, nil] post via this relay service only
+      # @return [Boolean] +false+ if at least one relay refused the connection or
+      #   +true+ otherwise
+      def say(message, on: nil)
+        Rodbot.config(:plugin).select do |extension, config|
+          config[:say] == true && (!on || extension == on)
+        end.keys.inject(true) do |success, extension|
+          write(message, extension) && success
+        end
+      end
+
+      private
+
+      # Write a message to a relay service extension
+      #
+      # @param message [String] message to post
+      # @param extension [Symbol] post via this relay service
+      # @return [Boolean] +false+ if the connection was refused or +true+ otherwise
+      def write(message, extension)
+        uri = URI(Rodbot::Services::Relay.url(extension))
+        Socket.tcp(uri.host, uri.port, connect_timeout: 3) do |socket|
+          socket.write message
+          socket.write "\x04"
+        end
+        true
+      rescue Errno::ECONNREFUSED
+        warn "WARNING: say via relay #{extension} failed as connection was refused"
+        false
+      end
+    end
+
+    # Loops which will be called by the relay service
+    #
+    # @abstract
+    # @return [Array<Proc>]
+    def loops
+      fail(Rodbot::RelayError, "loops method is not implemented")
+    end
+
+#   # @abstract
+#   def login
+#     fail(Rodbot::RelayError, "login not necessary")
+#   end
+#
+#   # @abstract
+#   def logout
+#     fail(Rodbot::RelayError, "logout not possible")
+#   end
+
+    private
+
+    # @return [Symbol] name of the relay extension
+    memoize def name
+      self.class.to_s.split('::')[-2].downcase.to_sym
+    end
+
+    # @see {Rodbot::Relay.bind}
+    # @return [String] designated "IP:port"
+    memoize def bind
+      [
+        (ENV["RODBOT_RELAY_HOST"] || 'localhost'),
+        Rodbot.config(:port) + 1 + Rodbot.config(:plugin).keys.index(name)
+      ]
+    end
+
+    # Perform the command on the app using a GET request
+    #
+    # @param command [String] command to perform
+    # @param argument [String, nil] optional arguments
+    # @return [String] response as Markdown
+    def command(command, argument=nil)
+      response = Rodbot.request(command, query: { argument: argument })
+      case response.code
+        when 200 then response.body
+        when 404 then "[[SENDER]] I don't know what do do with `!#{command}`. 🤔"
+        else fail
+      end
+    rescue
+      "[[SENDER]] I'm having trouble talking to the app. 💣"
+    end
+
+  end
+end