lex-slack 0.1.0 → 0.3.0

data/lib/legion/extensions/slack/actors/message_poller.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Slack
+      module Actor
+        class MessagePoller
+          include Helpers::Client
+
+          def initialize
+            @hwm = {}
+          end
+
+          def run
+            return unless enabled?
+            return if channels.empty?
+
+            token = settings.dig('lex-slack', 'token')
+            limit = settings.dig('lex-slack', 'poller', 'limit') || 50
+
+            channels.each do |channel_id|
+              poll_channel(channel_id, token: token, limit: limit)
+            end
+          end
+
+          def interval
+            settings.dig('lex-slack', 'poller', 'interval') || 30
+          end
+
+          private
+
+          def enabled?
+            settings.dig('lex-slack', 'poller', 'enabled') == true
+          end
+
+          def channels
+            settings.dig('lex-slack', 'poller', 'channels') || []
+          end
+
+          def poll_channel(channel_id, token:, limit:)
+            params = { channel: channel_id, limit: limit }
+            params[:oldest] = @hwm[channel_id] if @hwm[channel_id]
+
+            conn = api_connection(token: token)
+            resp = conn.get('conversations.history', params)
+            body = resp.body
+            return unless body['ok']
+
+            messages = body['messages'] || []
+            return if messages.empty?
+
+            @hwm[channel_id] = messages.map { |m| m['ts'] }.max
+            messages.each { |msg| publish_message(channel_id, msg) }
+          end
+
+          def publish_message(channel_id, message)
+            if defined?(Legion::Transport::Message)
+              Legion::Transport::Message.new(
+                function:  'handle_message',
+                namespace: 'Legion::Extensions::Slack',
+                args:      { channel: channel_id, message: message }
+              )
+            elsif defined?(Legion::Logging)
+              Legion::Logging::Logger.info "Slack message in #{channel_id}: #{message['text']}"
+            end
+          rescue StandardError => e
+            Legion::Logging::Logger.warn "Failed to publish slack message: #{e.message}" if defined?(Legion::Logging)
+          end
+
+          def settings
+            return Legion::Settings.to_h if defined?(Legion::Settings)
+
+            {}
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/slack/client.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require_relative 'helpers/client'
+require_relative 'runners/blocks'
+require_relative 'runners/chat'
+require_relative 'runners/conversations'
+require_relative 'runners/users'
+require_relative 'runners/reactions'
+require_relative 'runners/files'
+require_relative 'runners/pins'
+require_relative 'runners/bookmarks'
+require_relative 'runners/reminders'
+require_relative 'runners/usergroups'
+require_relative 'runners/views'
+require_relative 'runners/search'
+
+module Legion
+  module Extensions
+    module Slack
+      class Client
+        include Helpers::Client
+        include Runners::Blocks
+        include Runners::Chat
+        include Runners::Conversations
+        include Runners::Users
+        include Runners::Reactions
+        include Runners::Files
+        include Runners::Pins
+        include Runners::Bookmarks
+        include Runners::Reminders
+        include Runners::Usergroups
+        include Runners::Views
+        include Runners::Search
+
+        attr_reader :opts
+
+        def initialize(token: nil, webhook: nil, **extra)
+          @opts = { token: token, webhook: webhook, **extra }.compact
+        end
+
+        def api_connection(**override)
+          super(**@opts, **override)
+        end
+
+        def webhook_connection(**override)
+          super(**@opts, **override)
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/slack/helpers/client.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require 'faraday'
+
+module Legion
+  module Extensions
+    module Slack
+      module Helpers
+        module Client
+          def api_connection(token: nil, base_url: 'https://slack.com/api/', **)
+            Faraday.new(url: base_url) do |conn|
+              conn.request :json
+              conn.response :json, content_type: /\bjson$/
+              conn.headers['Authorization'] = "Bearer #{token}" if token
+              conn.adapter Faraday.default_adapter
+            end
+          end
+
+          def webhook_connection(base_url: 'https://hooks.slack.com', **)
+            Faraday.new(url: base_url) do |conn|
+              conn.request :json
+              conn.response :json, content_type: /\bjson$/
+              conn.adapter Faraday.default_adapter
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/slack/runners/blocks.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Slack
+      module Runners
+        module Blocks
+          def mrkdwn(text)
+            { type: 'mrkdwn', text: text }
+          end
+
+          def plain_text(text, emoji: true)
+            { type: 'plain_text', text: text, emoji: emoji }
+          end
+
+          def option(text:, value:)
+            { text: plain_text(text), value: value }
+          end
+
+          def section(text:, accessory: nil, fields: nil)
+            block = { type: 'section', text: mrkdwn(text) }
+            block[:accessory] = accessory if accessory
+            block[:fields] = fields if fields
+            block
+          end
+
+          def divider
+            { type: 'divider' }
+          end
+
+          def header(text:)
+            { type: 'header', text: plain_text(text) }
+          end
+
+          def context(elements:)
+            { type: 'context', elements: elements }
+          end
+
+          def actions(elements:, block_id: nil)
+            block = { type: 'actions', elements: elements }
+            block[:block_id] = block_id if block_id
+            block
+          end
+
+          def image(image_url:, alt_text:, title: nil, block_id: nil)
+            block = { type: 'image', image_url: image_url, alt_text: alt_text }
+            block[:title] = plain_text(title) if title
+            block[:block_id] = block_id if block_id
+            block
+          end
+
+          def input(label:, element:, block_id: nil, optional: false, dispatch_action: false)
+            block = { type: 'input', label: plain_text(label), element: element,
+                      optional: optional, dispatch_action: dispatch_action }
+            block[:block_id] = block_id if block_id
+            block
+          end
+
+          def file_block(external_id:, block_id: nil)
+            block = { type: 'file', external_id: external_id, source: 'remote' }
+            block[:block_id] = block_id if block_id
+            block
+          end
+
+          def button(text:, action_id:, value: nil, style: nil, url: nil)
+            el = { type: 'button', text: plain_text(text), action_id: action_id }
+            el[:value] = value if value
+            el[:style] = style if style
+            el[:url] = url if url
+            el
+          end
+
+          def overflow_menu(action_id:, options:)
+            { type: 'overflow', action_id: action_id, options: options }
+          end
+
+          def static_select(action_id:, placeholder:, options:)
+            { type: 'static_select', action_id: action_id,
+              placeholder: plain_text(placeholder), options: options }
+          end
+
+          def multi_static_select(action_id:, placeholder:, options:)
+            { type: 'multi_static_select', action_id: action_id,
+              placeholder: plain_text(placeholder), options: options }
+          end
+
+          def datepicker(action_id:, placeholder: nil, initial_date: nil)
+            el = { type: 'datepicker', action_id: action_id }
+            el[:placeholder] = plain_text(placeholder) if placeholder
+            el[:initial_date] = initial_date if initial_date
+            el
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/slack/runners/bookmarks.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Slack
+      module Runners
+        module Bookmarks
+          include Helpers::Client
+
+          def add_bookmark(channel:, title:, type:, token: nil, link: nil, emoji: nil, **)
+            payload = { channel_id: channel, title: title, type: type }
+            payload[:link] = link if link
+            payload[:emoji] = emoji if emoji
+            conn = api_connection(token: token, **)
+            resp = conn.post('bookmarks.add', payload)
+            { ok: resp.body['ok'], bookmark: resp.body['bookmark'] }
+          end
+
+          def edit_bookmark(channel:, bookmark_id:, token: nil, title: nil, link: nil, emoji: nil, **)
+            payload = { channel_id: channel, bookmark_id: bookmark_id }
+            payload[:title] = title if title
+            payload[:link] = link if link
+            payload[:emoji] = emoji if emoji
+            conn = api_connection(token: token, **)
+            resp = conn.post('bookmarks.edit', payload)
+            { ok: resp.body['ok'], bookmark: resp.body['bookmark'] }
+          end
+
+          def remove_bookmark(channel:, bookmark_id:, token: nil, **)
+            conn = api_connection(token: token, **)
+            resp = conn.post('bookmarks.remove', { channel_id: channel, bookmark_id: bookmark_id })
+            { ok: resp.body['ok'] }
+          end
+
+          def list_bookmarks(channel:, token: nil, **)
+            conn = api_connection(token: token, **)
+            resp = conn.get('bookmarks.list', { channel_id: channel })
+            { ok: resp.body['ok'], bookmarks: resp.body['bookmarks'] }
+          end
+
+          include Legion::Extensions::Helpers::Lex if defined?(Legion::Extensions::Helpers::Lex)
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/slack/runners/chat.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Slack
+      module Runners
+        module Chat
+          include Helpers::Client
+
+          def post_message(channel:, text:, token: nil, blocks: nil, thread_ts: nil, unfurl_links: nil, **)
+            payload = { channel: channel, text: text }
+            payload[:blocks] = blocks if blocks
+            payload[:thread_ts] = thread_ts if thread_ts
+            payload[:unfurl_links] = unfurl_links unless unfurl_links.nil?
+            conn = api_connection(token: token, **)
+            resp = conn.post('chat.postMessage', payload)
+            { ok: resp.body['ok'], ts: resp.body['ts'], channel: resp.body['channel'],
+              message: resp.body['message'] }
+          end
+
+          def send_webhook(message:, webhook:, **)
+            conn = webhook_connection(**)
+            resp = conn.post(webhook, { text: message })
+            { success: resp.body.nil? || resp.body == 'ok' || resp.body == {}, body: resp.body }
+          end
+
+          def update_message(channel:, ts:, token: nil, text: nil, blocks: nil, **)
+            payload = { channel: channel, ts: ts }
+            payload[:text] = text if text
+            payload[:blocks] = blocks if blocks
+            conn = api_connection(token: token, **)
+            resp = conn.post('chat.update', payload)
+            { ok: resp.body['ok'], ts: resp.body['ts'], channel: resp.body['channel'] }
+          end
+
+          def delete_message(channel:, ts:, token: nil, **)
+            conn = api_connection(token: token, **)
+            resp = conn.post('chat.delete', { channel: channel, ts: ts })
+            { ok: resp.body['ok'] }
+          end
+
+          def schedule_message(channel:, text:, post_at:, token: nil, blocks: nil, **)
+            payload = { channel: channel, text: text, post_at: post_at }
+            payload[:blocks] = blocks if blocks
+            conn = api_connection(token: token, **)
+            resp = conn.post('chat.scheduleMessage', payload)
+            { ok: resp.body['ok'], scheduled_message_id: resp.body['scheduled_message_id'],
+              post_at: resp.body['post_at'] }
+          end
+
+          def delete_scheduled(channel:, scheduled_message_id:, token: nil, **)
+            conn = api_connection(token: token, **)
+            resp = conn.post('chat.deleteScheduledMessage',
+                             { channel: channel, scheduled_message_id: scheduled_message_id })
+            { ok: resp.body['ok'] }
+          end
+
+          include Legion::Extensions::Helpers::Lex if defined?(Legion::Extensions::Helpers::Lex)
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/slack/runners/conversations.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Slack
+      module Runners
+        module Conversations
+          include Helpers::Client
+
+          def list_conversations(token: nil, types: nil, cursor: nil, limit: 200, **)
+            params = { limit: limit }
+            params[:types] = types if types
+            params[:cursor] = cursor if cursor
+            conn = api_connection(token: token, **)
+            resp = conn.get('conversations.list', params)
+            { ok: resp.body['ok'], channels: resp.body['channels'],
+              response_metadata: resp.body['response_metadata'] }
+          end
+
+          def conversation_info(channel:, token: nil, **)
+            conn = api_connection(token: token, **)
+            resp = conn.get('conversations.info', { channel: channel })
+            { ok: resp.body['ok'], channel: resp.body['channel'] }
+          end
+
+          def conversation_history(channel:, token: nil, cursor: nil, limit: 100, oldest: nil, latest: nil, **)
+            params = { channel: channel, limit: limit }
+            params[:cursor] = cursor if cursor
+            params[:oldest] = oldest if oldest
+            params[:latest] = latest if latest
+            conn = api_connection(token: token, **)
+            resp = conn.get('conversations.history', params)
+            { ok: resp.body['ok'], messages: resp.body['messages'],
+              has_more: resp.body['has_more'], response_metadata: resp.body['response_metadata'] }
+          end
+
+          def conversation_replies(channel:, ts:, token: nil, cursor: nil, limit: 100, **)
+            params = { channel: channel, ts: ts, limit: limit }
+            params[:cursor] = cursor if cursor
+            conn = api_connection(token: token, **)
+            resp = conn.get('conversations.replies', params)
+            { ok: resp.body['ok'], messages: resp.body['messages'], has_more: resp.body['has_more'] }
+          end
+
+          def conversation_members(channel:, token: nil, cursor: nil, limit: 100, **)
+            params = { channel: channel, limit: limit }
+            params[:cursor] = cursor if cursor
+            conn = api_connection(token: token, **)
+            resp = conn.get('conversations.members', params)
+            { ok: resp.body['ok'], members: resp.body['members'],
+              response_metadata: resp.body['response_metadata'] }
+          end
+
+          def join_conversation(channel:, token: nil, **)
+            conn = api_connection(token: token, **)
+            resp = conn.post('conversations.join', { channel: channel })
+            { ok: resp.body['ok'], channel: resp.body['channel'] }
+          end
+
+          def leave_conversation(channel:, token: nil, **)
+            conn = api_connection(token: token, **)
+            resp = conn.post('conversations.leave', { channel: channel })
+            { ok: resp.body['ok'] }
+          end
+
+          def invite_to_conversation(channel:, users:, token: nil, **)
+            conn = api_connection(token: token, **)
+            resp = conn.post('conversations.invite', { channel: channel, users: users })
+            { ok: resp.body['ok'], channel: resp.body['channel'] }
+          end
+
+          def open_conversation(token: nil, users: nil, channel: nil, **)
+            payload = {}
+            payload[:users] = users if users
+            payload[:channel] = channel if channel
+            conn = api_connection(token: token, **)
+            resp = conn.post('conversations.open', payload)
+            { ok: resp.body['ok'], channel: resp.body['channel'] }
+          end
+
+          def create_conversation(name:, token: nil, is_private: false, **)
+            conn = api_connection(token: token, **)
+            resp = conn.post('conversations.create', { name: name, is_private: is_private })
+            { ok: resp.body['ok'], channel: resp.body['channel'] }
+          end
+
+          def archive_conversation(channel:, token: nil, **)
+            conn = api_connection(token: token, **)
+            resp = conn.post('conversations.archive', { channel: channel })
+            { ok: resp.body['ok'] }
+          end
+
+          def set_conversation_topic(channel:, topic:, token: nil, **)
+            conn = api_connection(token: token, **)
+            resp = conn.post('conversations.setTopic', { channel: channel, topic: topic })
+            { ok: resp.body['ok'], topic: resp.body['topic'] }
+          end
+
+          include Legion::Extensions::Helpers::Lex if defined?(Legion::Extensions::Helpers::Lex)
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/slack/runners/files.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Slack
+      module Runners
+        module Files
+          include Helpers::Client
+
+          def upload_file(filename:, content:, token: nil, channel: nil, title: nil, **)
+            conn = api_connection(token: token, **)
+            url_resp = conn.get('files.getUploadURLExternal',
+                                { filename: filename, length: content.bytesize })
+            upload_url = url_resp.body['upload_url']
+            file_id = url_resp.body['file_id']
+            Faraday.put(upload_url, content, { 'Content-Type' => 'application/octet-stream' })
+            complete_payload = { files: [{ id: file_id, title: title || filename }] }
+            complete_payload[:channel_id] = channel if channel
+            complete_resp = conn.post('files.completeUploadExternal', complete_payload)
+            { ok: complete_resp.body['ok'], files: complete_resp.body['files'] }
+          end
+
+          def list_files(token: nil, channel: nil, user: nil, types: nil, cursor: nil, limit: 100, **)
+            params = { limit: limit }
+            params[:channel] = channel if channel
+            params[:user] = user if user
+            params[:types] = types if types
+            params[:cursor] = cursor if cursor
+            conn = api_connection(token: token, **)
+            resp = conn.get('files.list', params)
+            { ok: resp.body['ok'], files: resp.body['files'] }
+          end
+
+          def file_info(file:, token: nil, **)
+            conn = api_connection(token: token, **)
+            resp = conn.get('files.info', { file: file })
+            { ok: resp.body['ok'], file: resp.body['file'] }
+          end
+
+          def delete_file(file:, token: nil, **)
+            conn = api_connection(token: token, **)
+            resp = conn.post('files.delete', { file: file })
+            { ok: resp.body['ok'] }
+          end
+
+          def share_file(file:, token: nil, **)
+            conn = api_connection(token: token, **)
+            resp = conn.post('files.sharedPublicURL', { file: file })
+            { ok: resp.body['ok'], file: resp.body['file'] }
+          end
+
+          include Legion::Extensions::Helpers::Lex if defined?(Legion::Extensions::Helpers::Lex)
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/slack/runners/pins.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Slack
+      module Runners
+        module Pins
+          include Helpers::Client
+
+          def add_pin(channel:, timestamp:, token: nil, **)
+            conn = api_connection(token: token, **)
+            resp = conn.post('pins.add', { channel: channel, timestamp: timestamp })
+            { ok: resp.body['ok'] }
+          end
+
+          def remove_pin(channel:, timestamp:, token: nil, **)
+            conn = api_connection(token: token, **)
+            resp = conn.post('pins.remove', { channel: channel, timestamp: timestamp })
+            { ok: resp.body['ok'] }
+          end
+
+          def list_pins(channel:, token: nil, **)
+            conn = api_connection(token: token, **)
+            resp = conn.get('pins.list', { channel: channel })
+            { ok: resp.body['ok'], items: resp.body['items'] }
+          end
+
+          include Legion::Extensions::Helpers::Lex if defined?(Legion::Extensions::Helpers::Lex)
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/slack/runners/reactions.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Slack
+      module Runners
+        module Reactions
+          include Helpers::Client
+
+          def add_reaction(channel:, timestamp:, name:, token: nil, **)
+            conn = api_connection(token: token, **)
+            resp = conn.post('reactions.add', { channel: channel, timestamp: timestamp, name: name })
+            { ok: resp.body['ok'] }
+          end
+
+          def remove_reaction(channel:, timestamp:, name:, token: nil, **)
+            conn = api_connection(token: token, **)
+            resp = conn.post('reactions.remove', { channel: channel, timestamp: timestamp, name: name })
+            { ok: resp.body['ok'] }
+          end
+
+          def get_reactions(channel:, timestamp:, token: nil, **)
+            conn = api_connection(token: token, **)
+            resp = conn.get('reactions.get', { channel: channel, timestamp: timestamp })
+            { ok: resp.body['ok'], message: resp.body['message'] }
+          end
+
+          def list_reactions(token: nil, user: nil, cursor: nil, limit: 100, **)
+            params = { limit: limit }
+            params[:user] = user if user
+            params[:cursor] = cursor if cursor
+            conn = api_connection(token: token, **)
+            resp = conn.get('reactions.list', params)
+            { ok: resp.body['ok'], items: resp.body['items'],
+              response_metadata: resp.body['response_metadata'] }
+          end
+
+          include Legion::Extensions::Helpers::Lex if defined?(Legion::Extensions::Helpers::Lex)
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/slack/runners/reminders.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Slack
+      module Runners
+        module Reminders
+          include Helpers::Client
+
+          def add_reminder(text:, time:, token: nil, user: nil, **)
+            payload = { text: text, time: time }
+            payload[:user] = user if user
+            conn = api_connection(token: token, **)
+            resp = conn.post('reminders.add', payload)
+            { ok: resp.body['ok'], reminder: resp.body['reminder'] }
+          end
+
+          def complete_reminder(reminder:, token: nil, **)
+            conn = api_connection(token: token, **)
+            resp = conn.post('reminders.complete', { reminder: reminder })
+            { ok: resp.body['ok'] }
+          end
+
+          def delete_reminder(reminder:, token: nil, **)
+            conn = api_connection(token: token, **)
+            resp = conn.post('reminders.delete', { reminder: reminder })
+            { ok: resp.body['ok'] }
+          end
+
+          def reminder_info(reminder:, token: nil, **)
+            conn = api_connection(token: token, **)
+            resp = conn.get('reminders.info', { reminder: reminder })
+            { ok: resp.body['ok'], reminder: resp.body['reminder'] }
+          end
+
+          def list_reminders(token: nil, **)
+            conn = api_connection(token: token, **)
+            resp = conn.get('reminders.list', {})
+            { ok: resp.body['ok'], reminders: resp.body['reminders'] }
+          end
+
+          include Legion::Extensions::Helpers::Lex if defined?(Legion::Extensions::Helpers::Lex)
+        end
+      end
+    end
+  end
+end