openclacky 1.0.4 → 1.1.0

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

@@ -0,0 +1,177 @@
+# frozen_string_literal: true
+
+require_relative "../../adapters/base"
+require_relative "stream_client"
+require_relative "api_client"
+
+module Clacky
+  module Channel
+    module Adapters
+      module DingTalk
+        class Adapter < Base
+          def self.platform_id
+            :dingtalk
+          end
+
+          def self.env_keys
+            %w[IM_DINGTALK_CLIENT_ID IM_DINGTALK_CLIENT_SECRET IM_DINGTALK_ALLOWED_USERS]
+          end
+
+          def self.platform_config(data)
+            {
+              client_id:     data["IM_DINGTALK_CLIENT_ID"],
+              client_secret: data["IM_DINGTALK_CLIENT_SECRET"],
+              allowed_users: data["IM_DINGTALK_ALLOWED_USERS"]&.split(",")&.map(&:strip)&.reject(&:empty?)
+            }
+          end
+
+          def self.set_env_data(data, config)
+            data["IM_DINGTALK_CLIENT_ID"]     = config[:client_id]
+            data["IM_DINGTALK_CLIENT_SECRET"]  = config[:client_secret]
+            data["IM_DINGTALK_ALLOWED_USERS"]  = Array(config[:allowed_users]).join(",")
+          end
+
+          def self.test_connection(fields)
+            client = ApiClient.new(
+              client_id:     fields[:client_id].to_s.strip,
+              client_secret: fields[:client_secret].to_s.strip
+            )
+            client.test_connection
+          rescue => e
+            { ok: false, error: e.message }
+          end
+
+          def initialize(config)
+            @config        = config
+            @api_client    = ApiClient.new(
+              client_id:     config[:client_id],
+              client_secret: config[:client_secret]
+            )
+            @stream_client = nil
+            @running       = false
+            # chat_id => { url:, expires_at_ms: } — sessionWebhook is per-message
+            # and expires (~2h). We cache it from inbound events and validate on send.
+            @webhook_urls  = {}
+            @webhook_mutex = Mutex.new
+          end
+
+          WEBHOOK_SAFETY_MARGIN_MS = 5 * 60 * 1000
+
+          def start(&on_message)
+            @running    = true
+            @on_message = on_message
+
+            @stream_client = StreamClient.new(
+              client_id:     @config[:client_id],
+              client_secret: @config[:client_secret]
+            )
+            @stream_client.start { |frame| handle_frame(frame) }
+          end
+
+          def stop
+            @running = false
+            @stream_client&.stop
+          end
+
+          # @param chat_id [String] — for DingTalk Stream Mode, chat_id == webhook URL
+          def send_text(chat_id, text, reply_to: nil)
+            webhook_url = resolve_webhook(chat_id)
+            unless webhook_url
+              Clacky::Logger.warn("[dingtalk] no valid sessionWebhook for chat #{chat_id} (expired or never received)")
+              return { ok: false, error: "session_webhook_expired" }
+            end
+            @api_client.send_via_webhook(webhook_url, text)
+          end
+
+          def validate_config(config)
+            errors = []
+            errors << "client_id is required"     if config[:client_id].to_s.strip.empty?
+            errors << "client_secret is required" if config[:client_secret].to_s.strip.empty?
+            errors
+          end
+
+          private def handle_frame(frame)
+            topic = frame.dig("headers", "topic").to_s
+            return unless topic == "/v1.0/im/bot/messages/get"
+
+            data = begin
+              raw = frame["data"]
+              raw.is_a?(String) ? JSON.parse(raw) : raw
+            rescue JSON::ParserError
+              Clacky::Logger.warn("[dingtalk] failed to parse event data")
+              return
+            end
+
+            sender_id    = data.dig("senderStaffId") || data.dig("senderId") || ""
+            chat_id      = data.dig("conversationId") || sender_id
+            webhook_url  = data.dig("sessionWebhook") || ""
+            expired_ms   = (data.dig("sessionWebhookExpiredTime") || 0).to_i
+            text         = extract_text(data)
+            conv_type    = data.dig("conversationType").to_s  # "1"=DM, "2"=group
+
+            cache_webhook(chat_id, webhook_url, expired_ms) unless webhook_url.empty?
+
+            return if sender_id.empty?
+
+            # Group chats: only respond when @-mentioned
+            if conv_type == "2"
+              content = data.dig("text", "content").to_s
+              at_users = Array(data.dig("atUsers")).map { |u| u.dig("dingtalkId") || u.dig("staffId") || "" }
+              bot_id   = data.dig("chatbotUserId").to_s
+              unless at_users.include?(bot_id) || content.include?("@")
+                return
+              end
+            end
+
+            allowed = @config[:allowed_users]
+            return if allowed && !allowed.empty? && !allowed.include?(sender_id)
+
+            event = {
+              platform:   :dingtalk,
+              user_id:    sender_id,
+              chat_id:    chat_id,
+              message_id: data.dig("msgId") || "",
+              text:       text,
+              files:      [],
+              chat_type:  conv_type == "2" ? :group : :direct
+            }
+
+            Clacky::Logger.info("[dingtalk] message from #{sender_id}: #{text.to_s[0, 80]}")
+            @on_message&.call(event)
+          rescue => e
+            Clacky::Logger.warn("[dingtalk] handle_frame error: #{e.message}")
+          end
+
+          private def extract_text(data)
+            content = data.dig("text", "content").to_s.strip
+            # Strip leading @bot mention if present
+            content.gsub(/^@\S+\s*/, "").strip
+          end
+
+          private def cache_webhook(chat_id, url, expired_ms)
+            @webhook_mutex.synchronize do
+              @webhook_urls[chat_id] = { url: url, expires_at_ms: expired_ms }
+            end
+          end
+
+          private def resolve_webhook(chat_id)
+            entry = @webhook_mutex.synchronize { @webhook_urls[chat_id] }
+            return nil unless entry
+
+            expires_at = entry[:expires_at_ms].to_i
+            if expires_at > 0
+              now_ms = (Time.now.to_f * 1000).to_i
+              if now_ms + WEBHOOK_SAFETY_MARGIN_MS >= expires_at
+                @webhook_mutex.synchronize { @webhook_urls.delete(chat_id) }
+                return nil
+              end
+            end
+            entry[:url]
+          end
+        end
+
+        Adapters.register(:dingtalk, Adapter)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "uri"
+require "json"
+
+module Clacky
+  module Channel
+    module Adapters
+      module DingTalk
+        # DingTalk Bot API client — sends messages via session webhook (Stream Mode).
+        class ApiClient
+          OPENAPI_BASE = "https://api.dingtalk.com"
+
+          def initialize(client_id:, client_secret:)
+            @client_id     = client_id
+            @client_secret = client_secret
+            @token         = nil
+            @token_expires_at = 0
+          end
+
+          # Send a text (or Markdown) message via the session webhook URL.
+          # In Stream Mode, inbound events carry a `sessionWebhook` — use that directly.
+          # @param webhook_url [String]
+          # @param text [String]
+          # @param msg_type [:text, :markdown] (default :text)
+          def send_via_webhook(webhook_url, text, msg_type: :text)
+            body = if msg_type == :markdown
+              { msgtype: "markdown", markdown: { title: "Reply", text: text } }
+            else
+              { msgtype: "text", text: { content: text } }
+            end
+
+            uri = URI.parse(webhook_url)
+            http = Net::HTTP.new(uri.host, uri.port)
+            http.use_ssl = uri.scheme == "https"
+            req = Net::HTTP::Post.new(uri.request_uri, "Content-Type" => "application/json")
+            req.body = JSON.generate(body)
+            resp = http.request(req)
+            data = JSON.parse(resp.body) rescue {}
+            if resp.code.to_i != 200 || (data["errcode"] && data["errcode"] != 0)
+              Clacky::Logger.warn("[dingtalk] webhook send rejected (#{resp.code}): #{resp.body}")
+            end
+            data
+          rescue => e
+            Clacky::Logger.warn("[dingtalk] webhook send failed: #{e.message}")
+            {}
+          end
+
+          # Fetch a short-lived access token (cached for its lifetime).
+          def access_token
+            return @token if @token && Time.now.to_i < @token_expires_at - 60
+
+            uri  = URI.parse("#{OPENAPI_BASE}/v1.0/oauth2/accessToken")
+            http = Net::HTTP.new(uri.host, uri.port)
+            http.use_ssl = true
+            req = Net::HTTP::Post.new(uri.path, "Content-Type" => "application/json")
+            req.body = JSON.generate({ appKey: @client_id, appSecret: @client_secret })
+
+            resp = http.request(req)
+            data = JSON.parse(resp.body)
+
+            raise "DingTalk token error (#{resp.code}): #{data["message"] || resp.body}" unless resp.code.to_i == 200
+
+            @token = data["accessToken"] || raise("Missing accessToken in response")
+            @token_expires_at = Time.now.to_i + (data["expireIn"] || 7200).to_i
+            @token
+          end
+
+          # Validate credentials by fetching a token.
+          # @return [Hash] { ok: Boolean, error: String? }
+          def test_connection
+            access_token
+            { ok: true, message: "DingTalk access token obtained" }
+          rescue => e
+            { ok: false, error: e.message }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/clacky/server/channel/adapters/dingtalk/stream_client.rb

@@ -0,0 +1,205 @@
+# frozen_string_literal: true
+
+require "websocket"
+require "json"
+require "net/http"
+require "uri"
+
+module Clacky
+  module Channel
+    module Adapters
+      module DingTalk
+        DINGTALK_API_BASE = "https://api.dingtalk.com"
+        RECONNECT_DELAY   = 5
+
+        # WebSocket Stream Mode client for DingTalk.
+        # DingTalk Stream Mode uses JSON frames (unlike Feishu's protobuf).
+        # Frame shape:
+        #   { "specVersion": "1.0", "type": "SYSTEM"|"EVENT"|"CALLBACK",
+        #     "headers": { "messageId": "...", "time": "...", "topic": "...", ... },
+        #     "data": "..." }
+        class StreamClient
+          def initialize(client_id:, client_secret:)
+            @client_id     = client_id
+            @client_secret = client_secret
+            @running       = false
+          end
+
+          def start(&on_event)
+            @running  = true
+            @on_event = on_event
+            Clacky::Logger.info("[dingtalk-ws] Starting stream client (client_id=#{@client_id})")
+
+            while @running
+              begin
+                connect_and_listen
+              rescue => e
+                Clacky::Logger.warn("[dingtalk-ws] Connection error: #{e.class}: #{e.message}")
+                sleep RECONNECT_DELAY if @running
+              end
+            end
+          end
+
+          def stop
+            @running = false
+            @ws_socket&.close rescue nil
+          end
+
+          private def connect_and_listen
+            Clacky::Logger.info("[dingtalk-ws] Fetching stream endpoint...")
+            endpoint, ticket = fetch_stream_endpoint
+            full_url = "#{endpoint}?ticket=#{ticket}"
+            Clacky::Logger.info("[dingtalk-ws] Connecting to #{endpoint}")
+
+            uri  = URI.parse(full_url)
+            port = uri.port || 443
+            tcp  = TCPSocket.new(uri.host, port)
+
+            socket = begin
+              require "openssl"
+              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
+              ssl
+            end
+
+            handshake = WebSocket::Handshake::Client.new(url: full_url)
+            socket.write(handshake.to_s)
+            until handshake.finished?
+              handshake << socket.readpartial(4096)
+            end
+            raise "WebSocket handshake failed" unless handshake.valid?
+
+            Clacky::Logger.info("[dingtalk-ws] WebSocket connected")
+            @ws_version = handshake.version
+            @ws_socket  = socket
+            @incoming   = WebSocket::Frame::Incoming::Client.new(version: @ws_version)
+
+            loop do
+              break unless @running
+
+              ready = IO.select([socket], nil, nil, 120)
+              unless ready
+                Clacky::Logger.warn("[dingtalk-ws] read timeout, reconnecting...")
+                return
+              end
+
+              data = socket.read_nonblock(4096)
+              @incoming << data
+              while (frame = @incoming.next)
+                case frame.type
+                when :text   then handle_frame(frame.data)
+                when :ping   then send_frame(:pong, frame.data)
+                when :close
+                  Clacky::Logger.info("[dingtalk-ws] Server closed connection, will reconnect")
+                  return
+                end
+              end
+            end
+          rescue EOFError, IOError, Errno::ECONNRESET, Errno::EPIPE,
+                 Errno::ETIMEDOUT, OpenSSL::SSL::SSLError => e
+            raise
+          ensure
+            @ws_socket = nil
+            socket&.close rescue nil
+          end
+
+          private def fetch_stream_endpoint
+            uri  = URI.parse("#{DINGTALK_API_BASE}/v1.0/gateway/connections/open")
+            http = Net::HTTP.new(uri.host, uri.port)
+            http.use_ssl = true
+
+            req = Net::HTTP::Post.new(uri.path)
+            req["Content-Type"]  = "application/json"
+            req["Accept"]        = "application/json"
+            req.body = JSON.generate({
+              clientId:     @client_id,
+              clientSecret: @client_secret,
+              subscriptions: [
+                { type: "CALLBACK", topic: "/v1.0/im/bot/messages/get" }
+              ],
+              ua:      self.class.client_identifier,
+              localIp: "127.0.0.1"
+            })
+
+            resp = http.request(req)
+            data = JSON.parse(resp.body)
+
+            unless resp.code.to_i == 200
+              raise "Stream endpoint error (#{resp.code}): #{data["message"] || resp.body}"
+            end
+
+            endpoint = data.dig("endpoint") || raise("Missing endpoint in response")
+            ticket   = data.dig("ticket")   || ""
+            [endpoint, ticket]
+          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 handle_frame(json_text)
+            frame = JSON.parse(json_text)
+            type  = frame["type"]
+
+            case type
+            when "SYSTEM"
+              handle_system(frame)
+            when "EVENT", "CALLBACK"
+              send_ack(frame)
+              @on_event&.call(frame)
+            end
+          rescue JSON::ParserError => e
+            Clacky::Logger.warn("[dingtalk-ws] JSON parse error: #{e.message}")
+          end
+
+          private def handle_system(frame)
+            topic = frame.dig("headers", "topic").to_s
+            case topic
+            when "ping"
+              pong = frame.merge("type" => "SYSTEM",
+                                 "headers" => frame["headers"].merge("topic" => "pong"))
+              send_text(JSON.generate(pong))
+              Clacky::Logger.info("[dingtalk-ws] pong sent")
+            when "disconnect"
+              Clacky::Logger.warn("[dingtalk-ws] Server requested disconnect, will reconnect")
+              @ws_socket&.close rescue nil
+            end
+          end
+
+          private def send_ack(frame)
+            ack = {
+              "code"    => 200,
+              "headers" => {
+                "messageId" => frame.dig("headers", "messageId"),
+                "topic"     => "ack"
+              },
+              "message" => "OK",
+              "data"    => ""
+            }
+            send_text(JSON.generate(ack))
+          end
+
+          private def send_frame(type, data)
+            return unless @ws_socket
+            outgoing = WebSocket::Frame::Outgoing::Client.new(
+              version: @ws_version || 13,
+              data:    data,
+              type:    type
+            )
+            @ws_socket.write(outgoing.to_s)
+          end
+
+          private def send_text(text)
+            send_frame(:text, text)
+          end
+        end
+      end
+    end
+  end
+end

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