openclacky 1.0.4 → 1.0.5

data/lib/clacky/server/channel/adapters/discord/adapter.rb

@@ -0,0 +1,229 @@
+# frozen_string_literal: true
+
+require_relative "../../adapters/base"
+require_relative "api_client"
+require_relative "gateway_client"
+require_relative "../feishu/file_processor"
+require "time"
+
+module Clacky
+  module Channel
+    module Adapters
+      module Discord
+        # Discord adapter (bot mode).
+        # Receives messages via the Gateway WebSocket and sends via the REST API.
+        class Adapter < Base
+          MAX_IMAGE_BYTES = Clacky::Utils::FileProcessor::MAX_IMAGE_BYTES
+
+          def self.platform_id
+            :discord
+          end
+
+          def self.env_keys
+            %w[IM_DISCORD_BOT_TOKEN]
+          end
+
+          def self.platform_config(data)
+            {
+              bot_token: data["IM_DISCORD_BOT_TOKEN"]
+            }
+          end
+
+          def self.set_env_data(data, config)
+            data["IM_DISCORD_BOT_TOKEN"] = config[:bot_token]
+          end
+
+          def self.test_connection(fields)
+            bot_token = fields[:bot_token].to_s.strip
+            return { ok: false, error: "bot_token is required" } if bot_token.empty?
+
+            client = ApiClient.new(bot_token: bot_token)
+            me     = client.me
+            if me["id"]
+              { ok: true, message: "Connected as #{me["username"]}##{me["discriminator"]} (id=#{me["id"]})" }
+            else
+              { ok: false, error: "Empty response from /users/@me" }
+            end
+          rescue ApiClient::ApiError => e
+            { ok: false, error: e.message }
+          rescue StandardError => e
+            { ok: false, error: e.message }
+          end
+
+          def initialize(config)
+            @config       = config
+            @bot_token    = config[:bot_token]
+            @api          = ApiClient.new(bot_token: @bot_token)
+            @gateway      = GatewayClient.new(bot_token: @bot_token)
+            @bot_user_id  = nil
+            @running      = false
+            @on_message   = nil
+          end
+
+          def start(&on_message)
+            @running    = true
+            @on_message = on_message
+
+            begin
+              me = @api.me
+              @bot_user_id = me["id"]
+              Clacky::Logger.info("[DiscordAdapter] authenticated as #{me["username"]} (id=#{@bot_user_id})")
+            rescue ApiClient::ApiError => e
+              Clacky::Logger.error("[DiscordAdapter] /users/@me failed, not retrying: #{e.message}")
+              return
+            end
+
+            @gateway.start do |evt|
+              handle_gateway_event(evt)
+            end
+          rescue GatewayClient::AuthError => e
+            Clacky::Logger.error("[DiscordAdapter] Authentication failed, not retrying: #{e.message}")
+          end
+
+          def stop
+            @running = false
+            @gateway.stop
+          end
+
+          def send_text(chat_id, text, reply_to: nil)
+            res = @api.send_message(chat_id, text, reply_to: reply_to)
+            { message_id: res["id"] }
+          rescue ApiClient::ApiError => e
+            Clacky::Logger.error("[DiscordAdapter] send_text failed: #{e.message}")
+            { message_id: nil }
+          end
+
+          def update_message(chat_id, message_id, text)
+            @api.edit_message(chat_id, message_id, text)
+            true
+          rescue ApiClient::ApiError => e
+            Clacky::Logger.warn("[DiscordAdapter] update_message failed: #{e.message}")
+            false
+          end
+
+          def supports_message_updates?
+            true
+          end
+
+          def send_file(chat_id, path, name: nil)
+            @api.send_file(chat_id, path, name: name)
+          rescue ApiClient::ApiError => e
+            Clacky::Logger.error("[DiscordAdapter] send_file failed: #{e.message}")
+            nil
+          end
+
+          def validate_config(config)
+            errors = []
+            errors << "bot_token is required" if config[:bot_token].nil? || config[:bot_token].empty?
+            errors
+          end
+
+          private def handle_gateway_event(evt)
+            return unless evt[:type] == :message
+            handle_message(evt[:data])
+          end
+
+          private def handle_message(msg)
+            return if msg.nil?
+            author = msg["author"] || {}
+
+            return if author["bot"] == true
+            return if @bot_user_id && author["id"] == @bot_user_id
+
+            chat_id   = msg["channel_id"]
+            return unless chat_id
+
+            user_id   = author["id"]
+            chat_type = msg["guild_id"] ? :group : :direct
+            mentioned_ids = Array(msg["mentions"]).map { |m| m["id"] }
+
+            if chat_type == :group
+              if @bot_user_id.nil?
+                Clacky::Logger.warn("[DiscordAdapter] bot_user_id unavailable; dropping group message")
+                return
+              end
+              return unless mentioned_ids.include?(@bot_user_id)
+            end
+
+            allowed_users = @config[:allowed_users]
+            if allowed_users && !allowed_users.empty?
+              return unless allowed_users.include?(user_id)
+            end
+
+            text  = strip_bot_mention(msg["content"].to_s, @bot_user_id)
+            files = process_attachments(Array(msg["attachments"]), chat_id)
+
+            return if text.strip.empty? && files.empty?
+
+            event = {
+              type: :message,
+              platform: :discord,
+              chat_id: chat_id,
+              user_id: user_id,
+              text: text,
+              files: files,
+              message_id: msg["id"],
+              timestamp: parse_timestamp(msg["timestamp"]),
+              chat_type: chat_type,
+              mentioned_user_ids: mentioned_ids,
+              raw: msg
+            }
+
+            @on_message&.call(event)
+          rescue => e
+            Clacky::Logger.error("[DiscordAdapter] handle_message error: #{e.message}\n#{e.backtrace.first(3).join("\n")}")
+            begin
+              chat_id ||= msg && msg["channel_id"]
+              @api.send_message(chat_id, "Error processing message: #{e.message}") if chat_id
+            rescue
+              nil
+            end
+          end
+
+          private def strip_bot_mention(text, bot_id)
+            return text if bot_id.nil? || text.empty?
+            text.gsub(/<@!?#{Regexp.escape(bot_id)}>/, "").strip
+          end
+
+          private def process_attachments(attachments, chat_id)
+            files = []
+            attachments.each do |att|
+              url      = att["url"]
+              filename = att["filename"] || "attachment"
+              next unless url
+
+              result = @api.download(url)
+              body   = result[:body]
+              mime   = att["content_type"] || result[:content_type]
+
+              if mime && mime.start_with?("image/")
+                if body.bytesize > MAX_IMAGE_BYTES
+                  @api.send_message(chat_id, "Image too large (#{(body.bytesize / 1024.0).round(0).to_i}KB), max #{MAX_IMAGE_BYTES / 1024}KB")
+                  next
+                end
+                require "base64"
+                data_url = "data:#{mime};base64,#{Base64.strict_encode64(body)}"
+                files << { name: filename, mime_type: mime, data_url: data_url }
+              else
+                files << Clacky::Utils::FileProcessor.save(body: body, filename: filename)
+              end
+            end
+            files
+          rescue => e
+            Clacky::Logger.warn("[DiscordAdapter] process_attachments error: #{e.message}")
+            files
+          end
+
+          private def parse_timestamp(iso)
+            return Time.now if iso.nil? || iso.empty?
+            Time.iso8601(iso)
+          rescue ArgumentError
+            Time.now
+          end
+        end
+
+        Adapters.register(:discord, Adapter)
+      end
+    end
+  end
+end

data/lib/clacky/server/channel/adapters/discord/api_client.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+require "faraday"
+require "json"
+
+module Clacky
+  module Channel
+    module Adapters
+      module Discord
+        class ApiClient
+          DEFAULT_HOMEPAGE_URL = "https://discord.com"
+          BASE_URL             = "#{DEFAULT_HOMEPAGE_URL}/api/v10/"
+
+          class ApiError < StandardError; end
+
+          def initialize(bot_token:)
+            @bot_token = bot_token
+            @conn = Faraday.new(url: BASE_URL) do |f|
+              f.headers["Authorization"] = "Bot #{@bot_token}"
+              f.headers["User-Agent"]    = self.class.user_agent
+              f.response :raise_error
+              f.adapter Faraday.default_adapter
+            end
+          end
+
+          def me
+            request(:get, "users/@me")
+          end
+
+          def send_message(channel_id, content, reply_to: nil)
+            payload = { content: content.to_s }
+            payload[:message_reference] = { message_id: reply_to.to_s } if reply_to
+            request(:post, "channels/#{channel_id}/messages", payload)
+          end
+
+          def edit_message(channel_id, message_id, content)
+            request(:patch, "channels/#{channel_id}/messages/#{message_id}", { content: content.to_s })
+          end
+
+          def send_file(channel_id, path, name: nil)
+            raise ArgumentError, "File not found: #{path}" unless File.exist?(path)
+            filename = name || File.basename(path)
+            payload  = { attachments: [{ id: 0, filename: filename }] }
+            io       = Faraday::UploadIO.new(path, detect_mime(path), filename)
+
+            res = @conn.post("channels/#{channel_id}/messages") do |req|
+              req.body = { "payload_json" => JSON.generate(payload), "files[0]" => io }
+            end
+            parse_json(res.body)
+          rescue Faraday::Error => e
+            raise_api_error(e)
+          end
+
+          def download(url)
+            res = Faraday.get(url)
+            { body: res.body, content_type: res.headers["content-type"] }
+          end
+
+          # Discord requires User-Agent of the form "DiscordBot ($url, $versionNumber)".
+          # Requests with an invalid UA may be blocked at Cloudflare.
+          def self.user_agent
+            url = (Clacky::BrandConfig.load.homepage_url rescue nil) || DEFAULT_HOMEPAGE_URL
+            "DiscordBot (#{url}, #{Clacky::VERSION})"
+          end
+
+          private def request(verb, path, body = nil)
+            res = @conn.run_request(verb, path, body ? JSON.generate(body) : nil,
+                                    { "Content-Type" => "application/json" })
+            parse_json(res.body)
+          rescue Faraday::Error => e
+            raise_api_error(e)
+          end
+
+          private def raise_api_error(err)
+            status = err.response&.dig(:status)
+            body   = err.response&.dig(:body).to_s
+            parsed = (JSON.parse(body) rescue nil)
+            msg    = (parsed.is_a?(Hash) && parsed["message"]) || err.message
+            raise ApiError, "Discord API #{status}: #{msg}"
+          end
+
+          private def parse_json(body)
+            return {} if body.to_s.empty?
+            JSON.parse(body)
+          rescue JSON::ParserError => e
+            raise ApiError, "Invalid JSON response: #{e.message}"
+          end
+
+          private def detect_mime(path)
+            case File.extname(path).downcase
+            when ".jpg", ".jpeg" then "image/jpeg"
+            when ".png"          then "image/png"
+            when ".gif"          then "image/gif"
+            when ".webp"         then "image/webp"
+            when ".mp4"          then "video/mp4"
+            when ".mp3"          then "audio/mpeg"
+            when ".pdf"          then "application/pdf"
+            when ".txt"          then "text/plain"
+            when ".json"         then "application/json"
+            else                      "application/octet-stream"
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/clacky/server/channel/adapters/discord/gateway_client.rb

@@ -0,0 +1,272 @@
+# frozen_string_literal: true
+
+require "websocket"
+require "json"
+require "uri"
+require "openssl"
+require "socket"
+
+module Clacky
+  module Channel
+    module Adapters
+      module Discord
+        # WebSocket client for the Discord Gateway (v10, JSON, no compression).
+        # Implements identify, heartbeat, resume, and intent-aware error handling.
+        class GatewayClient
+          GATEWAY_URL = "wss://gateway.discord.gg/?v=10&encoding=json"
+
+          # GUILDS | GUILD_MESSAGES | GUILD_MESSAGE_REACTIONS | DIRECT_MESSAGES | MESSAGE_CONTENT
+          INTENTS = (1 << 0) | (1 << 9) | (1 << 10) | (1 << 12) | (1 << 15)
+
+          FATAL_CLOSE_CODES = [4004, 4010, 4011, 4012, 4013, 4014].freeze
+          RECONNECT_DELAY = 5
+          READ_TIMEOUT_S  = 90
+
+          class AuthError < StandardError; end
+
+          def initialize(bot_token:)
+            @bot_token = bot_token
+            @running   = false
+            @on_event  = nil
+
+            @session_id          = nil
+            @resume_gateway_url  = nil
+            @last_seq            = nil
+            @heartbeat_interval  = nil
+            @heartbeat_acked     = true
+            @heartbeat_thread    = nil
+
+            @ws_socket  = nil
+            @ws_open    = false
+            @ws_version = nil
+            @incoming   = nil
+          end
+
+          def start(&on_event)
+            @running  = true
+            @on_event = on_event
+
+            while @running
+              begin
+                connect_and_listen
+              rescue AuthError
+                @running = false
+                raise
+              rescue => e
+                Clacky::Logger.error("[DiscordGW] error: #{e.message}")
+                sleep RECONNECT_DELAY if @running
+              end
+            end
+          end
+
+          def stop
+            @running = false
+            @heartbeat_thread&.kill
+            send_raw_frame(:close, "") rescue nil
+            @ws_socket&.close rescue nil
+          end
+
+          private def connect_and_listen
+            ssl = nil
+            url = @resume_gateway_url ? "#{@resume_gateway_url}/?v=10&encoding=json" : GATEWAY_URL
+            uri = URI.parse(url)
+            port = uri.port || 443
+
+            Clacky::Logger.info("[DiscordGW] connecting to #{uri.host}:#{port} (resume=#{!@session_id.nil?})")
+
+            tcp = TCPSocket.new(uri.host, port)
+            ctx = OpenSSL::SSL::SSLContext.new
+            ctx.set_params(verify_mode: OpenSSL::SSL::VERIFY_PEER)
+            ssl = OpenSSL::SSL::SSLSocket.new(tcp, ctx)
+            ssl.hostname = uri.host
+            ssl.sync_close = true
+            ssl.connect
+
+            handshake = WebSocket::Handshake::Client.new(url: url)
+            ssl.write(handshake.to_s)
+            handshake << ssl.readpartial(4096) until handshake.finished?
+            raise "Gateway WebSocket handshake failed" unless handshake.valid?
+
+            @ws_version = handshake.version
+            @ws_socket  = ssl
+            @ws_open    = true
+            @incoming   = WebSocket::Frame::Incoming::Client.new(version: @ws_version)
+            @heartbeat_acked = true
+
+            loop do
+              break unless @running
+              ready = IO.select([ssl], nil, nil, READ_TIMEOUT_S)
+              unless ready
+                Clacky::Logger.warn("[DiscordGW] read timeout, reconnecting")
+                return
+              end
+
+              data = ssl.read_nonblock(4096)
+              @incoming << data
+              while (frame = @incoming.next)
+                case frame.type
+                when :text
+                  handle_payload(JSON.parse(frame.data))
+                when :ping
+                  send_raw_frame(:pong, frame.data)
+                when :close
+                  handle_close_frame(frame.data)
+                  return
+                end
+              end
+            end
+          rescue EOFError, IOError, Errno::ECONNRESET, Errno::EPIPE,
+                 Errno::ETIMEDOUT, OpenSSL::SSL::SSLError => e
+            Clacky::Logger.info("[DiscordGW] connection lost (#{e.class}: #{e.message})")
+          ensure
+            @ws_open = false
+            @ws_socket = nil
+            @heartbeat_thread&.kill
+            ssl&.close rescue nil
+          end
+
+          private def handle_payload(payload)
+            op   = payload["op"]
+            data = payload["d"]
+            seq  = payload["s"]
+            type = payload["t"]
+
+            @last_seq = seq if seq
+
+            case op
+            when 10
+              @heartbeat_interval = data["heartbeat_interval"]
+              Clacky::Logger.info("[DiscordGW] hello, heartbeat_interval=#{@heartbeat_interval}ms")
+              start_heartbeat_thread
+              if @session_id && @resume_gateway_url
+                send_resume
+              else
+                send_identify
+              end
+            when 0
+              handle_dispatch(type, data)
+            when 1
+              send_heartbeat
+            when 7
+              Clacky::Logger.info("[DiscordGW] server requested reconnect")
+              @ws_socket&.close rescue nil
+            when 9
+              resumable = data == true
+              Clacky::Logger.warn("[DiscordGW] invalid session (resumable=#{resumable})")
+              unless resumable
+                @session_id = nil
+                @resume_gateway_url = nil
+                @last_seq = nil
+              end
+              sleep(rand(1..5))
+              @ws_socket&.close rescue nil
+            when 11
+              @heartbeat_acked = true
+            end
+          end
+
+          private def handle_dispatch(type, data)
+            case type
+            when "READY"
+              @session_id         = data["session_id"]
+              @resume_gateway_url = data["resume_gateway_url"]
+              user = data["user"] || {}
+              Clacky::Logger.info("[DiscordGW] READY as #{user["username"]} (id=#{user["id"]}), session=#{@session_id}")
+            when "RESUMED"
+              Clacky::Logger.info("[DiscordGW] RESUMED session=#{@session_id}")
+            when "MESSAGE_CREATE"
+              @on_event&.call(type: :message, data: data)
+            end
+          rescue => e
+            Clacky::Logger.error("[DiscordGW] dispatch handler error (#{type}): #{e.message}\n#{e.backtrace.first(3).join("\n")}")
+          end
+
+          private def handle_close_frame(data)
+            code   = data.respond_to?(:code) ? data.code : nil
+            reason = data.respond_to?(:data) ? data.data : data.to_s
+            Clacky::Logger.warn("[DiscordGW] close frame code=#{code} reason=#{reason}")
+            if code && FATAL_CLOSE_CODES.include?(code)
+              @running = false
+              raise AuthError, "Discord rejected connection (code=#{code}): #{reason}"
+            end
+          end
+
+          private def send_identify
+            Clacky::Logger.info("[DiscordGW] sending Identify (intents=#{INTENTS})")
+            client_id = self.class.client_identifier
+            send_payload(
+              op: 2,
+              d: {
+                token: @bot_token,
+                intents: INTENTS,
+                properties: {
+                  os:      RUBY_PLATFORM,
+                  browser: client_id,
+                  device:  client_id
+                }
+              }
+            )
+          end
+
+          def self.client_identifier
+            name = Clacky::BrandConfig.load.product_name
+            name = "OpenClacky" if name.nil? || name.strip.empty?
+            "#{name.strip}/#{Clacky::VERSION}"
+          end
+
+          private def send_resume
+            Clacky::Logger.info("[DiscordGW] sending Resume (session=#{@session_id} seq=#{@last_seq})")
+            send_payload(
+              op: 6,
+              d: { token: @bot_token, session_id: @session_id, seq: @last_seq }
+            )
+          end
+
+          private def send_heartbeat
+            unless @heartbeat_acked
+              Clacky::Logger.warn("[DiscordGW] missed heartbeat ack, forcing reconnect")
+              @ws_socket&.close rescue nil
+              return
+            end
+            @heartbeat_acked = false
+            send_payload(op: 1, d: @last_seq)
+          end
+
+          private def start_heartbeat_thread
+            @heartbeat_thread&.kill
+            interval_s = @heartbeat_interval.to_f / 1000.0
+            jitter     = rand
+            @heartbeat_thread = Thread.new do
+              sleep(interval_s * jitter)
+              loop do
+                break unless @running && @ws_open
+                begin
+                  send_heartbeat
+                rescue => e
+                  Clacky::Logger.warn("[DiscordGW] heartbeat send failed: #{e.message}")
+                  @ws_socket&.close rescue nil
+                  break
+                end
+                sleep interval_s
+              end
+            end
+          end
+
+          private def send_payload(payload)
+            send_raw_frame(:text, JSON.generate(payload))
+          end
+
+          private def send_raw_frame(type, data)
+            return unless @ws_socket && @ws_open
+            outgoing = WebSocket::Frame::Outgoing::Client.new(
+              version: @ws_version || 13,
+              data:    data,
+              type:    type
+            )
+            @ws_socket.write(outgoing.to_s)
+          end
+        end
+      end
+    end
+  end
+end