chat_sdk 0.1.0

data/lib/chat_sdk/testing/fake_adapter.rb

@@ -0,0 +1,195 @@
+# frozen_string_literal: true
+
+module ChatSDK
+  module Testing
+    class FakeAdapter < Adapter::Base
+      capabilities :edit_messages, :delete_messages, :ephemeral_messages,
+        :file_uploads, :reactions, :modals, :typing_indicator,
+        :streaming_edit, :threads, :direct_messages, :message_history
+
+      attr_reader :posted_messages, :edited_messages, :deleted_messages,
+        :ephemeral_messages_sent, :reactions_added, :reactions_removed,
+        :files_uploaded, :modals_opened, :typing_started, :dm_channels
+
+      def initialize
+        reset!
+      end
+
+      def name
+        :test
+      end
+
+      def client
+        self
+      end
+
+      def verify_request!(rack_request)
+        true
+      end
+
+      def ack_response(rack_request)
+        nil
+      end
+
+      def parse_events(rack_request)
+        []
+      end
+
+      def post_message(channel_id:, message:, thread_id: nil)
+        record = RecordedCall.new(:post_message, channel_id: channel_id, message: message, thread_id: thread_id)
+        @posted_messages << record
+        Message.new(
+          id: "msg_#{@posted_messages.size}",
+          text: message.is_a?(PostableMessage) ? message.text : message.to_s,
+          author: Author.new(id: "bot", name: "test-bot", platform: :test, bot: true),
+          thread_id: thread_id,
+          channel_id: channel_id,
+          platform: :test
+        )
+      end
+
+      def edit_message(channel_id:, message_id:, message:)
+        record = RecordedCall.new(:edit_message, channel_id: channel_id, message_id: message_id, message: message)
+        @edited_messages << record
+        record
+      end
+
+      def delete_message(channel_id:, message_id:)
+        record = RecordedCall.new(:delete_message, channel_id: channel_id, message_id: message_id)
+        @deleted_messages << record
+        record
+      end
+
+      def post_ephemeral(channel_id:, user_id:, message:, thread_id: nil)
+        record = RecordedCall.new(:post_ephemeral, channel_id: channel_id, user_id: user_id, message: message, thread_id: thread_id)
+        @ephemeral_messages_sent << record
+        record
+      end
+
+      def upload_file(channel_id:, io:, filename:, thread_id: nil, comment: nil)
+        record = RecordedCall.new(:upload_file, channel_id: channel_id, filename: filename, thread_id: thread_id, comment: comment)
+        @files_uploaded << record
+        record
+      end
+
+      def add_reaction(channel_id:, message_id:, emoji:)
+        record = RecordedCall.new(:add_reaction, channel_id: channel_id, message_id: message_id, emoji: emoji)
+        @reactions_added << record
+        record
+      end
+
+      def remove_reaction(channel_id:, message_id:, emoji:)
+        record = RecordedCall.new(:remove_reaction, channel_id: channel_id, message_id: message_id, emoji: emoji)
+        @reactions_removed << record
+        record
+      end
+
+      def open_dm(user_id)
+        channel_id = "dm_#{user_id}"
+        @dm_channels << RecordedCall.new(:open_dm, user_id: user_id, channel_id: channel_id)
+        channel_id
+      end
+
+      def fetch_messages(channel_id:, thread_id: nil, cursor: nil, limit: 50)
+        [[], nil]
+      end
+
+      def open_modal(trigger_id:, modal:)
+        record = RecordedCall.new(:open_modal, trigger_id: trigger_id, modal: modal)
+        @modals_opened << record
+        record
+      end
+
+      def start_typing(channel_id:, thread_id: nil)
+        record = RecordedCall.new(:start_typing, channel_id: channel_id, thread_id: thread_id)
+        @typing_started << record
+        record
+      end
+
+      def mention(user_id)
+        "<@#{user_id}>"
+      end
+
+      def render(postable_message)
+        Cards::Renderer.new.render(postable_message.card)
+      end
+
+      # Simulation helpers
+      def simulate_mention(chat, text:, user_id: "U123", user_name: "testuser", channel_id: "C123", thread_id: nil)
+        thread_id ||= "T#{rand(1000..9999)}"
+        author = Author.new(id: user_id, name: user_name, platform: :test)
+        message = Message.new(
+          id: "evt_#{rand(10000..99999)}",
+          text: text,
+          author: author,
+          thread_id: thread_id,
+          channel_id: channel_id,
+          platform: :test
+        )
+        event = Events::Mention.new(
+          message: message,
+          thread_id: thread_id,
+          channel_id: channel_id,
+          platform: :test,
+          adapter_name: :test
+        )
+        chat.dispatch(event, adapter_name: :test)
+      end
+
+      def simulate_action(chat, action_id:, value: nil, user_id: "U123", channel_id: "C123", thread_id: "T123", trigger_id: nil)
+        user = Author.new(id: user_id, name: "testuser", platform: :test)
+        event = Events::Action.new(
+          action_id: action_id,
+          value: value,
+          user: user,
+          thread_id: thread_id,
+          channel_id: channel_id,
+          trigger_id: trigger_id,
+          platform: :test,
+          adapter_name: :test
+        )
+        chat.dispatch(event, adapter_name: :test)
+      end
+
+      def simulate_reaction(chat, emoji:, user_id: "U123", message_id: "M123", channel_id: "C123", thread_id: "T123", added: true)
+        event = Events::Reaction.new(
+          emoji: emoji,
+          user_id: user_id,
+          message_id: message_id,
+          thread_id: thread_id,
+          channel_id: channel_id,
+          added: added,
+          platform: :test,
+          adapter_name: :test
+        )
+        chat.dispatch(event, adapter_name: :test)
+      end
+
+      def simulate_slash_command(chat, command:, text: "", user_id: "U123", channel_id: "C123", trigger_id: nil)
+        event = Events::SlashCommand.new(
+          command: command,
+          text: text,
+          user_id: user_id,
+          channel_id: channel_id,
+          trigger_id: trigger_id,
+          platform: :test,
+          adapter_name: :test
+        )
+        chat.dispatch(event, adapter_name: :test)
+      end
+
+      def reset!
+        @posted_messages = []
+        @edited_messages = []
+        @deleted_messages = []
+        @ephemeral_messages_sent = []
+        @reactions_added = []
+        @reactions_removed = []
+        @files_uploaded = []
+        @modals_opened = []
+        @typing_started = []
+        @dm_channels = []
+      end
+    end
+  end
+end

data/lib/chat_sdk/testing/helpers.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module ChatSDK
+  module Testing
+    module Helpers
+      def build_bot(**options)
+        ChatSDK::Testing.build_bot(**options)
+      end
+
+      def fake_adapter
+        @fake_adapter ||= FakeAdapter.new
+      end
+
+      def build_message(text: "hello", user_id: "U123", user_name: "testuser", channel_id: "C123", thread_id: "T123")
+        author = Author.new(id: user_id, name: user_name, platform: :test)
+        Message.new(
+          id: "msg_#{rand(10000..99999)}",
+          text: text,
+          author: author,
+          thread_id: thread_id,
+          channel_id: channel_id,
+          platform: :test
+        )
+      end
+
+      def build_card(title: "Test Card", &block)
+        ChatSDK.card(title: title, &block)
+      end
+    end
+  end
+end

data/lib/chat_sdk/testing/recorded_call.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module ChatSDK
+  module Testing
+    class RecordedCall
+      attr_reader :method_name, :arguments
+
+      def initialize(method_name, **arguments)
+        @method_name = method_name
+        @arguments = arguments
+      end
+
+      def [](key)
+        @arguments[key]
+      end
+
+      def to_h
+        {method: @method_name}.merge(@arguments)
+      end
+    end
+  end
+end

data/lib/chat_sdk/testing/state_contract.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module ChatSDK
+  module Testing
+    module StateContract
+      RSpec.shared_examples "a chat_sdk state adapter" do
+        describe "subscriptions" do
+          it "subscribes and checks" do
+            subject.subscribe("thread_1")
+            expect(subject.subscribed?("thread_1")).to be true
+          end
+
+          it "unsubscribes" do
+            subject.subscribe("thread_1")
+            subject.unsubscribe("thread_1")
+            expect(subject.subscribed?("thread_1")).to be false
+          end
+
+          it "returns false for unsubscribed threads" do
+            expect(subject.subscribed?("nonexistent")).to be false
+          end
+        end
+
+        describe "locks" do
+          it "acquires a lock" do
+            expect(subject.acquire_lock("key1", owner: "a", ttl: 10)).to be true
+          end
+
+          it "prevents double acquisition" do
+            subject.acquire_lock("key1", owner: "a", ttl: 10)
+            expect(subject.acquire_lock("key1", owner: "b", ttl: 10)).to be false
+          end
+
+          it "releases a lock by owner" do
+            subject.acquire_lock("key1", owner: "a", ttl: 10)
+            expect(subject.release_lock("key1", owner: "a")).to be true
+            expect(subject.acquire_lock("key1", owner: "b", ttl: 10)).to be true
+          end
+
+          it "does not release lock with wrong owner" do
+            subject.acquire_lock("key1", owner: "a", ttl: 10)
+            expect(subject.release_lock("key1", owner: "b")).to be false
+          end
+
+          it "force acquires a lock" do
+            subject.acquire_lock("key1", owner: "a", ttl: 10)
+            expect(subject.force_lock("key1", owner: "b", ttl: 10)).to be true
+          end
+        end
+
+        describe "key-value store" do
+          it "gets and sets values" do
+            subject.set("k1", {"count" => 1})
+            expect(subject.get("k1")).to eq({"count" => 1})
+          end
+
+          it "returns nil for missing keys" do
+            expect(subject.get("missing")).to be_nil
+          end
+
+          it "deletes keys" do
+            subject.set("k1", "v1")
+            subject.delete("k1")
+            expect(subject.get("k1")).to be_nil
+          end
+
+          it "set_if_absent succeeds when key absent" do
+            expect(subject.set_if_absent("k1", "v1")).to be true
+            expect(subject.get("k1")).to eq("v1")
+          end
+
+          it "set_if_absent fails when key present" do
+            subject.set("k1", "v1")
+            expect(subject.set_if_absent("k1", "v2")).to be false
+            expect(subject.get("k1")).to eq("v1")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/chat_sdk/testing.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module ChatSDK
+  module Testing
+    class << self
+      def build_bot(adapters: nil, state: nil, **options)
+        adapters ||= {test: FakeAdapter.new}
+        state ||= State::Memory.new
+        Chat.new(user_name: "test-bot", adapters: adapters, state: state, **options)
+      end
+    end
+  end
+end

data/lib/chat_sdk/thread.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+module ChatSDK
+  class Thread
+    attr_reader :id, :channel_id, :adapter, :chat
+
+    def initialize(id:, channel_id:, adapter:, chat:)
+      @id = id
+      @channel_id = channel_id
+      @adapter = adapter
+      @chat = chat
+    end
+
+    def subscribe
+      chat.state.subscribe(state_key)
+    end
+
+    def unsubscribe
+      chat.state.unsubscribe(state_key)
+    end
+
+    def subscribed?
+      chat.state.subscribed?(state_key)
+    end
+
+    def post(content)
+      message = PostableMessage.from(content)
+      adapter.post_message(channel_id: channel_id, message: message, thread_id: id)
+    end
+
+    def post_ephemeral(content, user_id:)
+      message = PostableMessage.from(content)
+      adapter.post_ephemeral(channel_id: channel_id, user_id: user_id, message: message, thread_id: id)
+    end
+
+    def post_stream(placeholder: nil, &block)
+      stream = Streaming::Stream.new(
+        adapter: adapter,
+        channel_id: channel_id,
+        thread_id: id,
+        placeholder: placeholder,
+        update_interval: chat.config.streaming_update_interval
+      )
+      stream.run(&block)
+    end
+
+    def edit(message_id, content)
+      message = PostableMessage.from(content)
+      adapter.edit_message(channel_id: channel_id, message_id: message_id, message: message)
+    end
+
+    def delete(message_id)
+      adapter.delete_message(channel_id: channel_id, message_id: message_id)
+    end
+
+    def react(message_id, emoji)
+      adapter.add_reaction(channel_id: channel_id, message_id: message_id, emoji: emoji)
+    end
+
+    def unreact(message_id, emoji)
+      adapter.remove_reaction(channel_id: channel_id, message_id: message_id, emoji: emoji)
+    end
+
+    def upload(io:, filename:, comment: nil)
+      adapter.upload_file(channel_id: channel_id, io: io, filename: filename, thread_id: id, comment: comment)
+    end
+
+    def messages(cursor: nil, limit: 50)
+      adapter.fetch_messages(channel_id: channel_id, thread_id: id, cursor: cursor, limit: limit)
+    end
+
+    def state
+      chat.state.get(state_key(:state))
+    end
+
+    def set_state(value)
+      chat.state.set(state_key(:state), value, ttl: 30 * 24 * 3600)
+    end
+
+    def mention_user(user_id)
+      adapter.mention(user_id)
+    end
+
+    def open_modal(trigger_id:, modal:)
+      adapter.open_modal(trigger_id: trigger_id, modal: modal)
+    end
+
+    def ==(other)
+      other.is_a?(ChatSDK::Thread) && id == other.id && channel_id == other.channel_id
+    end
+    alias_method :eql?, :==
+
+    def hash
+      [id, channel_id].hash
+    end
+
+    private
+
+    def state_key(suffix = nil)
+      base = "#{adapter.name}:#{channel_id}:#{id}"
+      suffix ? "#{base}:#{suffix}" : base
+    end
+  end
+end

data/lib/chat_sdk/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module ChatSDK
+  VERSION = "0.1.0"
+end

data/lib/chat_sdk/webhook/endpoint.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module ChatSDK
+  module Webhook
+    class Endpoint
+      attr_reader :chat, :adapter, :adapter_name
+
+      def initialize(chat:, adapter:, adapter_name:)
+        @chat = chat
+        @adapter = adapter
+        @adapter_name = adapter_name
+      end
+
+      def call(env)
+        request = Rack::Request.new(env) if defined?(Rack)
+
+        adapter.verify_request!(request || env)
+
+        ack = adapter.ack_response(request || env)
+        return ack if ack
+
+        events = adapter.parse_events(request || env)
+        events.each { |event| chat.dispatch(event, adapter_name: adapter_name) }
+
+        [200, {"content-type" => "text/plain"}, [""]]
+      rescue ChatSDK::SignatureVerificationError => e
+        ChatSDK::Log.warn("Signature verification failed: #{e.message}")
+        [401, {"content-type" => "text/plain"}, ["Unauthorized"]]
+      rescue => e
+        ChatSDK::Log.error("Webhook error: #{e.message}")
+        [200, {"content-type" => "text/plain"}, [""]]
+      end
+    end
+  end
+end

data/lib/chat_sdk/webhook/router.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module ChatSDK
+  module Webhook
+    class Router
+      def initialize(chat, adapters)
+        @chat = chat
+        @adapters = adapters
+      end
+
+      def call(env)
+        path = env["PATH_INFO"].to_s.split("/").last&.to_sym
+        adapter = @adapters[path]
+
+        unless adapter
+          return [404, {"content-type" => "text/plain"}, ["Unknown adapter: #{path}"]]
+        end
+
+        endpoint = Endpoint.new(chat: @chat, adapter: adapter, adapter_name: path)
+        endpoint.call(env)
+      end
+    end
+  end
+end

data/lib/chat_sdk.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require "zeitwerk"
+require_relative "chat_sdk/version"
+require_relative "chat_sdk/errors"
+
+module ChatSDK
+  class << self
+    def loader
+      @loader ||= begin
+        loader = Zeitwerk::Loader.for_gem(warn_on_extra_files: false)
+        loader.inflector.inflect("chat_sdk" => "ChatSDK")
+        loader.ignore("#{__dir__}/chat_sdk/version.rb")
+        loader.ignore("#{__dir__}/chat_sdk/errors.rb")
+        loader.setup
+        loader
+      end
+    end
+
+    def card(title: nil, subtitle: nil, &block)
+      Cards::Builder.new(title: title, subtitle: subtitle, &block).build
+    end
+  end
+end
+
+ChatSDK.loader

metadata

@@ -0,0 +1,97 @@
+--- !ruby/object:Gem::Specification
+name: chat_sdk
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Rootly
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: zeitwerk
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.6'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.6'
+description: Platform-agnostic chat bot framework with normalized events, cards DSL,
+  streaming, and pluggable adapters
+email:
+- eng@rootly.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/chat_sdk.rb
+- lib/chat_sdk/adapter/base.rb
+- lib/chat_sdk/adapter/capabilities.rb
+- lib/chat_sdk/author.rb
+- lib/chat_sdk/cards/actions_context.rb
+- lib/chat_sdk/cards/builder.rb
+- lib/chat_sdk/cards/fields_context.rb
+- lib/chat_sdk/cards/node.rb
+- lib/chat_sdk/cards/renderer.rb
+- lib/chat_sdk/cards/select_context.rb
+- lib/chat_sdk/channel.rb
+- lib/chat_sdk/chat.rb
+- lib/chat_sdk/config.rb
+- lib/chat_sdk/dispatcher.rb
+- lib/chat_sdk/errors.rb
+- lib/chat_sdk/event_registry.rb
+- lib/chat_sdk/events/action.rb
+- lib/chat_sdk/events/base.rb
+- lib/chat_sdk/events/direct_message.rb
+- lib/chat_sdk/events/mention.rb
+- lib/chat_sdk/events/reaction.rb
+- lib/chat_sdk/events/slash_command.rb
+- lib/chat_sdk/events/subscribed_message.rb
+- lib/chat_sdk/log.rb
+- lib/chat_sdk/message.rb
+- lib/chat_sdk/modals/builder.rb
+- lib/chat_sdk/postable_message.rb
+- lib/chat_sdk/state/base.rb
+- lib/chat_sdk/state/memory.rb
+- lib/chat_sdk/streaming/stream.rb
+- lib/chat_sdk/testing.rb
+- lib/chat_sdk/testing/adapter_contract.rb
+- lib/chat_sdk/testing/fake_adapter.rb
+- lib/chat_sdk/testing/helpers.rb
+- lib/chat_sdk/testing/recorded_call.rb
+- lib/chat_sdk/testing/state_contract.rb
+- lib/chat_sdk/thread.rb
+- lib/chat_sdk/version.rb
+- lib/chat_sdk/webhook/endpoint.rb
+- lib/chat_sdk/webhook/router.rb
+homepage: https://github.com/rootlyhq/rootly-chat-sdk
+licenses:
+- MIT
+metadata:
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.2.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.16
+specification_version: 4
+summary: Unified Ruby SDK for building chat bots across Slack, Teams, Google Chat,
+  and more
+test_files: []