octo-agent 0.11.2

data/lib/octo/server/channel/adapters/wecom/adapter.rb

@@ -0,0 +1,148 @@
+# frozen_string_literal: true
+
+require_relative "../../adapters/base"
+require_relative "ws_client"
+require_relative "media_downloader"
+require_relative "../feishu/file_processor"
+
+module Octo
+  module Channel
+    module Adapters
+      module Wecom
+        # WeCom (Enterprise WeChat) adapter.
+        # Receives messages via WebSocket long connection and sends via bot API.
+        class Adapter < Base
+          def self.platform_id
+            :wecom
+          end
+
+          def self.env_keys
+            %w[IM_WECOM_BOT_ID IM_WECOM_SECRET]
+          end
+
+          def self.platform_config(data)
+            {
+              bot_id: data["IM_WECOM_BOT_ID"],
+              secret: data["IM_WECOM_SECRET"]
+            }
+          end
+
+          def self.set_env_data(data, config)
+            data["IM_WECOM_BOT_ID"] = config[:bot_id]
+            data["IM_WECOM_SECRET"] = config[:secret]
+          end
+
+          def initialize(config)
+            @config = config
+            @ws_client = WSClient.new(
+              bot_id: config[:bot_id],
+              secret: config[:secret],
+              ws_url: config[:ws_url] || WSClient::WS_URL
+            )
+            @running = false
+            @on_message = nil
+          end
+
+          def start(&on_message)
+            @running = true
+            @on_message = on_message
+
+            @ws_client.start do |raw|
+              handle_raw_message(raw)
+            end
+          rescue WSClient::AuthError => e
+            Octo::Logger.error("[WecomAdapter] Authentication failed, not retrying: #{e.message}")
+          end
+
+          def stop
+            @running = false
+            @ws_client.stop
+          end
+
+          def send_text(chat_id, text, reply_to: nil)
+            @ws_client.send_message(chat_id, text)
+          end
+
+          def send_file(chat_id, path, name: nil)
+            @ws_client.send_file(chat_id, path, name: name)
+          end
+
+          def validate_config(config)
+            errors = []
+            errors << "bot_id is required" if config[:bot_id].nil? || config[:bot_id].empty?
+            errors << "secret is required" if config[:secret].nil? || config[:secret].empty?
+            errors
+          end
+
+
+          def handle_raw_message(raw)
+            msgtype = raw["msgtype"]
+            return unless %w[text image file].include?(msgtype)
+
+            chat_id = raw["chatid"] || raw.dig("from", "userid")
+            return unless chat_id
+
+            user_id = raw.dig("from", "userid")
+            chat_type = raw["chattype"] == "group" ? :group : :direct
+            text  = ""
+            files = []
+
+            case msgtype
+            when "text"
+              text = raw.dig("text", "content").to_s.strip
+              return if text.empty?
+            when "image"
+              url    = raw.dig("image", "url")
+              aeskey = raw.dig("image", "aeskey")
+              return unless url
+              result = MediaDownloader.download(url, aeskey)
+              mime = MediaDownloader.detect_mime(result[:body])
+              if result[:body].bytesize > MAX_IMAGE_BYTES
+                @ws_client.send_message(chat_id, "Image too large (#{(result[:body].bytesize / 1024.0).round(0).to_i}KB), max #{MAX_IMAGE_BYTES / 1024}KB")
+                return
+              end
+              require "base64"
+              data_url = "data:#{mime};base64,#{Base64.strict_encode64(result[:body])}"
+              files = [{ name: "image.jpg", mime_type: mime, data_url: data_url }]
+            when "file"
+              url      = raw.dig("file", "url")
+              aeskey   = raw.dig("file", "aeskey")
+              return unless url
+              filename = raw.dig("file", "name") || raw.dig("file", "filename") || "attachment"
+              result   = MediaDownloader.download(url, aeskey)
+              filename = result[:filename] || filename
+              saved = Octo::Utils::FileProcessor.save(body: result[:body], filename: filename)
+              files = [saved]
+            end
+
+            event = {
+              type: :message,
+              platform: :wecom,
+              chat_id: chat_id,
+              user_id: user_id,
+              text: text,
+              files: files,
+              message_id: raw["msgid"],
+              timestamp: raw["create_time"] ? Time.at(raw["create_time"]) : Time.now,
+              chat_type: chat_type,
+              raw: raw
+            }
+
+            @on_message&.call(event)
+          rescue => e
+            Octo::Logger.error("[WecomAdapter] handle_raw_message error: #{e.message}\n#{e.backtrace.first(3).join("\n")}")
+            begin
+              @ws_client.send_message(chat_id, "Error processing message: #{e.message}") if chat_id
+            rescue
+              nil
+            end
+          end
+
+          MAX_IMAGE_BYTES = Octo::Utils::FileProcessor::MAX_IMAGE_BYTES
+        end
+
+        Adapters.register(:wecom, Adapter)
+      end
+    end
+  end
+end

data/lib/octo/server/channel/adapters/wecom/media_downloader.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+require "openssl"
+require "faraday"
+require "uri"
+
+module Octo
+  module Channel
+    module Adapters
+      module Wecom
+        # Downloads and decrypts media files from WeCom message URLs.
+        #
+        # WeCom long-connection bot messages include a per-resource aeskey.
+        # Encryption: AES-256-CBC, key=base64_decode(aeskey), iv=key[0,16], no PKCS7 padding.
+        # However some files are sent unencrypted — detect via magic bytes before decrypting.
+        module MediaDownloader
+          HTTP_TIMEOUT = 30
+
+          # Download and decrypt a WeCom media resource.
+          # @param url [String] Signed download URL from the message
+          # @param aeskey [String] Per-resource AES key string
+          # @return [Hash] { body: String (binary), content_type: String }
+          def self.download(url, aeskey)
+            response = fetch(url)
+            body = response.body.dup.force_encoding("BINARY")
+
+            if aeskey && !aeskey.empty? && !looks_plain?(body)
+              body = decrypt(body, aeskey)
+            end
+
+            content_type = detect_mime(body)
+            filename = extract_filename(response.headers["content-disposition"].to_s)
+            { body: body, content_type: content_type, filename: filename }
+          end
+
+          def self.extract_filename(content_disposition)
+            return nil if content_disposition.empty?
+            # filename*=UTF-8''name.ext  or  filename="name.ext"
+            if (m = content_disposition.match(/filename\*=UTF-8''([^;\s]+)/i))
+              URI.decode_www_form_component(m[1])
+            elsif (m = content_disposition.match(/filename="?([^";\s]+)"?/i))
+              URI.decode_www_form_component(m[1])
+            end
+          end
+
+          # --- private ---
+
+          def self.fetch(url)
+            conn = Faraday.new do |f|
+              f.options.timeout = HTTP_TIMEOUT
+              f.options.open_timeout = HTTP_TIMEOUT
+              f.ssl.verify = false
+              f.adapter Faraday.default_adapter
+            end
+            response = conn.get(url)
+            raise "Failed to download media: HTTP #{response.status}" unless response.success?
+            response
+          end
+
+          # AES-256-CBC decrypt, no PKCS7 padding.
+          # Key = base64_decode(aeskey), IV = first 16 bytes of decoded key.
+          def self.decrypt(data, aeskey)
+            require "base64"
+            padded = aeskey + "=" * ((4 - aeskey.length % 4) % 4)
+            key = Base64.decode64(padded)
+            iv  = key.byteslice(0, 16)
+
+            cipher = OpenSSL::Cipher.new("AES-256-CBC")
+            cipher.decrypt
+            cipher.key = key
+            cipher.iv  = iv
+            cipher.padding = 0
+            cipher.update(data) + cipher.final
+          rescue OpenSSL::Cipher::CipherError => e
+            warn "[WeCom] AES decrypt failed: #{e.message}"
+            # Decryption failed — return raw data as-is
+            data
+          end
+
+          # Check if data looks like a plain (unencrypted) file via magic bytes.
+          MAGIC_SIGNATURES = [
+            "\xFF\xD8\xFF",         # JPEG
+            "\x89PNG\r\n\x1a\n",   # PNG
+            "GIF8",                  # GIF
+            "%PDF",                  # PDF
+            "PK\x03\x04",           # ZIP (docx/xlsx)
+            "\xD0\xCF\x11\xE0",    # OLE2 (doc/xls)
+            "RIFF",                  # WAV/WebP
+          ].map { |s| s.b }.freeze
+
+          def self.looks_plain?(data)
+            return false if data.empty?
+            MAGIC_SIGNATURES.any? { |sig| data.start_with?(sig) }
+          end
+
+          # Detect MIME type from magic bytes
+          # @param data [String] Binary data
+          # @return [String] MIME type
+          def self.detect_mime(data)
+            return "application/octet-stream" if data.nil? || data.empty?
+            d = data.b
+            return "image/jpeg"      if d.start_with?("\xFF\xD8\xFF".b)
+            return "image/png"       if d.start_with?("\x89PNG\r\n\x1a\n".b)
+            return "image/gif"       if d.start_with?("GIF8".b)
+            return "image/webp"      if d.start_with?("RIFF".b) && d.byteslice(8, 4) == "WEBP".b
+            return "image/bmp"       if d.start_with?("BM".b)
+            "image/jpeg"  # fallback for unknown image formats
+          end
+
+          private_class_method :fetch, :decrypt, :looks_plain?, :extract_filename
+        end
+      end
+    end
+  end
+end

data/lib/octo/server/channel/adapters/wecom/ws_client.rb

@@ -0,0 +1,395 @@
+# frozen_string_literal: true
+
+require "websocket"
+require "json"
+require "uri"
+require "securerandom"
+
+module Octo
+  module Channel
+    module Adapters
+      module Wecom
+        # WebSocket client for WeCom (Enterprise WeChat) intelligent robot long connection.
+        # Protocol: plain JSON frames over wss://openws.work.weixin.qq.com
+        #
+        # Frame format: { cmd, headers: { req_id }, body }
+        # Commands:
+        #   aibot_subscribe      - auth (client → server)
+        #   ping                 - heartbeat (client → server)
+        #   aibot_msg_callback   - inbound message (server → client)
+        #   aibot_respond_msg    - send reply (client → server)
+        class WSClient
+          WS_URL = "wss://openws.work.weixin.qq.com"
+          HEARTBEAT_INTERVAL = 30 # seconds
+          RECONNECT_DELAY = 5     # seconds
+
+          # Raised when WeCom rejects credentials — signals caller not to retry.
+          class AuthError < StandardError; end
+
+          def initialize(bot_id:, secret:, ws_url: WS_URL)
+            @bot_id = bot_id
+            @secret = secret
+            @ws_url = ws_url
+            @running = false
+            @ws = nil
+            @ping_thread = nil
+            @mutex = Mutex.new
+            @pending_acks = {}
+          end
+
+          def start(&on_message)
+            @running = true
+            @on_message = on_message
+
+            while @running
+              begin
+                connect_and_listen
+              rescue AuthError => e
+                Octo::Logger.error("[WecomWSClient] Authentication failed (not retrying): #{e.message}")
+                @running = false
+                raise
+              rescue => e
+                Octo::Logger.error("[WecomWSClient] WebSocket error: #{e.message}")
+                sleep RECONNECT_DELAY if @running
+              end
+            end
+          end
+
+          def stop
+            @running = false
+            @ping_thread&.kill
+            send_raw_frame(:close, "") rescue nil
+            @ws_socket&.close rescue nil
+          end
+
+          # Proactively send a text message
+          # @param chatid [String] chat ID
+          # @param content [String] text content
+          def send_message(chatid, content)
+            Octo::Logger.info("[WecomWSClient] send_message chat=#{chatid} length=#{content.length}")
+            send_frame_and_wait(
+              cmd: "aibot_send_msg",
+              req_id: generate_req_id("send"),
+              body: {
+                chatid: chatid,
+                msgtype: "markdown",
+                markdown: { content: content }
+              }
+            )
+          end
+
+          # Upload a local file as a temporary media asset and send it to a chat.
+          # Uses the three-step chunked upload protocol:
+          #   aibot_upload_media_init → aibot_upload_media_chunk × N → aibot_upload_media_finish
+          # Then sends the resulting media_id via aibot_send_msg.
+          #
+          # @param chatid   [String] target chat ID
+          # @param path     [String] absolute path to the local file
+          # @param name     [String, nil] display filename (defaults to File.basename(path))
+          # @param type     [String] media type — "file" or "image"
+          def send_file(chatid, path, name: nil, type: nil)
+            Octo::Logger.info("[WecomWSClient] send_file chat=#{chatid} path=#{path}")
+            raise ArgumentError, "File not found: #{path}" unless File.exist?(path)
+
+            data      = File.binread(path)
+            filename  = name || File.basename(path)
+            media_type = type || detect_media_type(path)
+
+            Octo::Logger.info("[WecomWSClient] uploading #{filename} (#{data.bytesize} bytes, type=#{media_type})")
+            media_id = upload_media(data, filename: filename, type: media_type)
+            Octo::Logger.info("[WecomWSClient] upload done media_id=#{media_id}")
+
+            req_id = generate_req_id("send_file")
+            send_frame_and_wait(
+              cmd: "aibot_send_msg",
+              req_id: req_id,
+              body: {
+                chatid: chatid,
+                msgtype: media_type,
+                media_type => { media_id: media_id }
+              }
+            )
+            Octo::Logger.info("[WecomWSClient] send_file frame sent chat=#{chatid} filename=#{filename}")
+          rescue => e
+            Octo::Logger.error("[WecomWSClient] send_file failed (#{File.basename(path)}): #{e.message}")
+            raise
+          end
+
+
+          # Timeout for IO.select on the read loop. If no data arrives within this
+          # window we treat the connection as dead and reconnect. This catches the
+          # silent-drop case where the TCP stack never delivers a FIN/RST (e.g.
+          # NAT timeout, firewall idle-kill). The WeCom server sends pings every
+          # ~30 s, so 75 s gives two missed pings before we give up.
+          READ_TIMEOUT_S = 75
+
+          def connect_and_listen
+            uri = URI.parse(@ws_url)
+            port = uri.port || 443
+
+            Octo::Logger.info("[WecomWSClient] connecting to #{uri.host}:#{port}")
+
+            require "openssl"
+            tcp = TCPSocket.new(uri.host, port)
+            ssl_context = OpenSSL::SSL::SSLContext.new
+            ssl_context.set_params(verify_mode: OpenSSL::SSL::VERIFY_PEER)
+            ssl = OpenSSL::SSL::SSLSocket.new(tcp, ssl_context)
+            ssl.sync_close = true
+            ssl.connect
+
+            # WebSocket handshake
+            handshake = WebSocket::Handshake::Client.new(url: @ws_url)
+            ssl.write(handshake.to_s)
+
+            until handshake.finished?
+              handshake << ssl.readpartial(4096)
+            end
+            raise "WebSocket handshake failed" unless handshake.valid?
+
+            Octo::Logger.info("[WecomWSClient] connected, authenticating")
+            @ws_version = handshake.version
+            @ws_socket  = ssl
+            @ws_open    = true
+            @incoming   = WebSocket::Frame::Incoming::Client.new(version: @ws_version)
+
+            authenticate
+            start_ping_thread
+
+            loop do
+              break unless @running
+
+              # Use IO.select with a timeout so we detect silent connection drops
+              # (e.g. NAT expiry) that never deliver a TCP FIN/RST. Without this,
+              # readpartial blocks forever and the thread hangs permanently.
+              ready = IO.select([ssl], nil, nil, READ_TIMEOUT_S)
+              unless ready
+                Octo::Logger.warn("[WecomWSClient] read timeout (#{READ_TIMEOUT_S}s), reconnecting...")
+                return
+              end
+
+              data = ssl.read_nonblock(4096)
+              @incoming << data
+              while (frame = @incoming.next)
+                case frame.type
+                when :text
+                  handle_message(frame.data)
+                when :ping
+                  send_raw_frame(:pong, frame.data)
+                when :close
+                  Octo::Logger.info("[WecomWSClient] connection closed by server")
+                  return
+                end
+              end
+            end
+          rescue EOFError, IOError, Errno::ECONNRESET, Errno::EPIPE,
+                 Errno::ETIMEDOUT, OpenSSL::SSL::SSLError => e
+            Octo::Logger.info("[WecomWSClient] connection lost (#{e.class}: #{e.message}), reconnecting...")
+          ensure
+            @ws_open = false
+            @ws_socket = nil
+            ssl&.close rescue nil
+            @ping_thread&.kill
+          end
+
+          def authenticate
+            Octo::Logger.info("[WecomWSClient] sending auth (bot_id=#{@bot_id})")
+            send_frame(
+              cmd: "aibot_subscribe",
+              req_id: generate_req_id("subscribe"),
+              body: { bot_id: @bot_id, secret: @secret }
+            )
+          end
+
+          def handle_message(data)
+            frame = JSON.parse(data)
+            cmd = frame["cmd"]
+            body = frame["body"] || {}
+            req_id = frame.dig("headers", "req_id") || ""
+
+            # Dispatch ack to any waiting send_frame_and_wait caller
+            if req_id && !req_id.empty?
+              queue = @mutex.synchronize { @pending_acks&.[](req_id) }
+              if queue
+                queue.push(frame)
+                return
+              end
+            end
+
+            case cmd
+            when "aibot_msg_callback"
+              Octo::Logger.info("[WecomWSClient] inbound message req_id=#{req_id}")
+              cb_body = body.merge("_req_id" => req_id)
+              Thread.new { @on_message&.call(cb_body) }
+            when "aibot_event_callback"
+              Octo::Logger.info("[WecomWSClient] event_callback (ignored)")
+            when nil
+              errcode = frame["errcode"] || body["errcode"]
+              if errcode && errcode != 0
+                Octo::Logger.error("[WecomWSClient] error response: #{frame.inspect}")
+                if req_id.start_with?("subscribe_")
+                  errmsg = frame["errmsg"] || body["errmsg"] || "unknown error"
+                  @running = false
+                  raise AuthError, "WeCom authentication failed (errcode=#{errcode}): #{errmsg}"
+                end
+              else
+                if req_id.start_with?("ping_")
+                  Octo::Logger.debug("[WecomWSClient] ack/heartbeat req_id=#{req_id}")
+                else
+                  Octo::Logger.info("[WecomWSClient] ack/heartbeat req_id=#{req_id}")
+                end
+              end
+            else
+              Octo::Logger.info("[WecomWSClient] unknown cmd=#{cmd}")
+            end
+          rescue JSON::ParserError => e
+            Octo::Logger.error("[WecomWSClient] failed to parse message: #{e.message}")
+          end
+
+          def send_frame(cmd:, req_id:, body: nil)
+            frame = { cmd: cmd, headers: { req_id: req_id } }
+            frame[:body] = body if body
+            if cmd == "ping"
+              Octo::Logger.debug("[WecomWSClient] >> cmd=#{cmd} req_id=#{req_id}")
+            else
+              Octo::Logger.info("[WecomWSClient] >> cmd=#{cmd} req_id=#{req_id}")
+            end
+            send_raw_frame(:text, JSON.generate(frame))
+          rescue => e
+            Octo::Logger.error("[WecomWSClient] failed to send frame cmd=#{cmd}: #{e.message}")
+          end
+
+          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
+
+          def start_ping_thread
+            @ping_thread&.kill
+            @ping_thread = Thread.new do
+              loop do
+                sleep HEARTBEAT_INTERVAL
+                break unless @running
+                begin
+                  send_frame(cmd: "ping", req_id: generate_req_id("ping"))
+                rescue => e
+                  Octo::Logger.warn("[WecomWSClient] ping failed (#{e.class}: #{e.message}), forcing reconnect")
+                  # Close the socket so IO.select in the read loop immediately
+                  # returns nil / read_nonblock raises IOError, triggering reconnect.
+                  @ws_socket&.close rescue nil
+                  break
+                end
+              end
+            end
+          end
+
+          def generate_req_id(prefix)
+            "#{prefix}_#{SecureRandom.hex(8)}"
+          end
+
+          CHUNK_SIZE = 512 * 1024  # 512 KB per chunk (before Base64)
+          MAX_CHUNKS = 100
+
+          # Three-step chunked media upload over WebSocket.
+          # Returns media_id on success.
+          def upload_media(data, filename:, type: "file")
+            require "base64"
+            require "digest"
+
+            total_size   = data.bytesize
+            total_chunks = (total_size.to_f / CHUNK_SIZE).ceil
+            total_chunks = 1 if total_chunks == 0
+            raise ArgumentError, "File too large: #{total_chunks} chunks (max #{MAX_CHUNKS})" if total_chunks > MAX_CHUNKS
+
+            md5 = Digest::MD5.hexdigest(data)
+
+            Octo::Logger.info("[WecomWSClient] upload_media_init filename=#{filename} size=#{total_size} chunks=#{total_chunks} md5=#{md5}")
+
+            # Step 1: init
+            init_req_id = generate_req_id("upload_init")
+            init_result = send_frame_and_wait(
+              cmd: "aibot_upload_media_init",
+              req_id: init_req_id,
+              body: { type: type, filename: filename, total_size: total_size, total_chunks: total_chunks, md5: md5 }
+            )
+            upload_id = init_result.dig("body", "upload_id")
+            raise "upload_media init failed: #{init_result.inspect}" unless upload_id
+            Octo::Logger.info("[WecomWSClient] upload_id=#{upload_id}")
+
+            # Step 2: chunks
+            total_chunks.times do |i|
+              chunk_start = i * CHUNK_SIZE
+              chunk       = data[chunk_start, CHUNK_SIZE]
+              b64         = Base64.strict_encode64(chunk)
+
+              Octo::Logger.info("[WecomWSClient] uploading chunk #{i + 1}/#{total_chunks}")
+              chunk_req_id = generate_req_id("upload_chunk")
+              send_frame_and_wait(
+                cmd: "aibot_upload_media_chunk",
+                req_id: chunk_req_id,
+                body: { upload_id: upload_id, chunk_index: i, base64_data: b64 }
+              )
+            end
+
+            # Step 3: finish
+            Octo::Logger.info("[WecomWSClient] upload_media_finish upload_id=#{upload_id}")
+            finish_req_id = generate_req_id("upload_finish")
+            finish_result = send_frame_and_wait(
+              cmd: "aibot_upload_media_finish",
+              req_id: finish_req_id,
+              body: { upload_id: upload_id }
+            )
+            media_id = finish_result.dig("body", "media_id")
+            raise "upload_media finish failed: #{finish_result.inspect}" unless media_id
+
+            media_id
+          end
+
+          # Send a frame and block until an ack frame with the same req_id arrives.
+          # Timeout after 30s. Returns the ack frame hash.
+          def send_frame_and_wait(cmd:, req_id:, body: nil)
+            queue = Queue.new
+
+            @mutex.synchronize do
+              @pending_acks ||= {}
+              @pending_acks[req_id] = queue
+            end
+
+            send_frame(cmd: cmd, req_id: req_id, body: body)
+
+            timeout_thread = Thread.new { sleep 30; queue.push(nil) }
+            result = queue.pop
+            timeout_thread.kill
+            raise "Timeout waiting for ack (req_id=#{req_id}, cmd=#{cmd})" if result.nil?
+
+            errcode = result["errcode"] || result.dig("body", "errcode")
+            if errcode && errcode != 0
+              errmsg = result["errmsg"] || result.dig("body", "errmsg") || "unknown"
+              raise "WeCom API error #{errcode}: #{errmsg} (cmd=#{cmd})"
+            end
+
+            result
+          ensure
+            @mutex.synchronize { @pending_acks&.delete(req_id) }
+          end
+
+          # Detect media type from file extension
+          def detect_media_type(path)
+            case File.extname(path).downcase
+            when ".jpg", ".jpeg", ".png", ".gif", ".webp" then "image"
+            when ".mp4", ".avi", ".mov", ".mkv"           then "video"
+            when ".mp3", ".wav", ".amr", ".m4a"           then "voice"
+            else "file"
+            end
+          end
+
+
+        end
+      end
+    end
+  end
+end