openclacky 0.9.11 → 0.9.13

data/lib/clacky/server/channel/adapters/feishu/ws_client.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require "websocket/driver"
+require "websocket"
 require "json"
 require "net/http"
 require "uri"
@@ -47,7 +47,8 @@ module Clacky
           def stop
             @running = false
             @ping_thread&.kill
-            @ws&.close
+            send_raw_frame(:close, "") rescue nil
+            @ws_socket&.close rescue nil
           end
 
           private
@@ -73,37 +74,48 @@ module Clacky
               tcp
             end
 
-            wrapper = SocketWrapper.new(socket, endpoint)
-            @ws = WebSocket::Driver.client(wrapper)
+            # WebSocket handshake
+            handshake = WebSocket::Handshake::Client.new(url: endpoint)
+            socket.write(handshake.to_s)
 
-            @ws.on :open do
-              Clacky::Logger.info("[feishu-ws] WebSocket connected")
+            # Read until handshake complete
+            until handshake.finished?
+              handshake << socket.readpartial(4096)
             end
+            raise "WebSocket handshake failed" unless handshake.valid?
 
-            @ws.on :message do |event|
-              data = event.data
-              handle_frame(data.respond_to?(:b) ? data.b : data)
-            end
-
-            @ws.on :error do |event|
-              Clacky::Logger.warn("[feishu-ws] WebSocket error: #{event.message}")
-            end
+            Clacky::Logger.info("[feishu-ws] WebSocket connected")
+            @ws_version = handshake.version
+            @ws_socket  = socket
+            @ws_open    = true
+            @incoming   = WebSocket::Frame::Incoming::Client.new(version: @ws_version)
 
-            @ws.on :close do |event|
-              Clacky::Logger.info("[feishu-ws] WebSocket closed (code=#{event.code}), will reconnect")
-            end
-
-            @ws.start
             start_ping_thread
 
             loop do
               break unless @running
               data = socket.readpartial(4096)
-              @ws.parse(data)
+              @incoming << data
+              while (frame = @incoming.next)
+                case frame.type
+                when :binary
+                  raw = frame.data
+                  handle_frame(raw.respond_to?(:b) ? raw.b : raw)
+                when :text
+                  handle_frame(frame.data)
+                when :ping
+                  send_raw_frame(:pong, frame.data)
+                when :close
+                  Clacky::Logger.info("[feishu-ws] WebSocket closed, will reconnect")
+                  return
+                end
+              end
             end
           rescue EOFError, Errno::ECONNRESET
             Clacky::Logger.warn("[feishu-ws] Connection lost, reconnecting in #{RECONNECT_DELAY}s...")
           ensure
+            @ws_open = false
+            @ws_socket = nil
             socket&.close rescue nil
             @ping_thread&.kill
           end
@@ -211,11 +223,21 @@ module Clacky
               payload: payload
             }
             encoded = ProtoFrame.encode(frame)
-            @ws.binary(encoded)
+            send_raw_frame(:binary, encoded)
           rescue => e
             warn "[feishu-ws] failed to send frame: #{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
@@ -365,19 +387,7 @@ module Clacky
             end
           end
 
-          # Wraps a raw socket for websocket-driver client mode.
-          class SocketWrapper
-            attr_reader :url
 
-            def initialize(socket, url)
-              @socket = socket
-              @url = url
-            end
-
-            def write(data)
-              @socket.write(data)
-            end
-          end
         end
       end
     end

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

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require "websocket/driver"
+require "websocket"
 require "json"
 require "uri"
 require "securerandom"
@@ -58,7 +58,8 @@ module Clacky
           def stop
             @running = false
             @ping_thread&.kill
-            @ws&.close
+            send_raw_frame(:close, "") rescue nil
+            @ws_socket&.close rescue nil
           end
 
           # Proactively send a text message
@@ -130,37 +131,45 @@ module Clacky
             ssl.sync_close = true
             ssl.connect
 
-            wrapper = SocketWrapper.new(ssl, @ws_url)
-            @ws = WebSocket::Driver.client(wrapper)
+            # WebSocket handshake
+            handshake = WebSocket::Handshake::Client.new(url: @ws_url)
+            ssl.write(handshake.to_s)
 
-            @ws.on :open do
-              Clacky::Logger.info("[WecomWSClient] connected, authenticating")
-              authenticate
-              start_ping_thread
+            until handshake.finished?
+              handshake << ssl.readpartial(4096)
             end
+            raise "WebSocket handshake failed" unless handshake.valid?
 
-            @ws.on :message do |event|
-              handle_message(event.data)
-            end
-
-            @ws.on :error do |event|
-              Clacky::Logger.error("[WecomWSClient] WS error: #{event.message}")
-            end
+            Clacky::Logger.info("[WecomWSClient] connected, authenticating")
+            @ws_version = handshake.version
+            @ws_socket  = ssl
+            @ws_open    = true
+            @incoming   = WebSocket::Frame::Incoming::Client.new(version: @ws_version)
 
-            @ws.on :close do
-              Clacky::Logger.info("[WecomWSClient] connection closed")
-            end
-
-            @ws.start
+            authenticate
+            start_ping_thread
 
             loop do
               break unless @running
               data = ssl.readpartial(4096)
-              @ws.parse(data)
+              @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
+                  Clacky::Logger.info("[WecomWSClient] connection closed")
+                  return
+                end
+              end
             end
           rescue EOFError, Errno::ECONNRESET
             Clacky::Logger.info("[WecomWSClient] connection lost, reconnecting...")
           ensure
+            @ws_open = false
+            @ws_socket = nil
             ssl&.close rescue nil
             @ping_thread&.kill
           end
@@ -227,11 +236,21 @@ module Clacky
             else
               Clacky::Logger.info("[WecomWSClient] >> cmd=#{cmd} req_id=#{req_id}")
             end
-            @ws.text(JSON.generate(frame))
+            send_raw_frame(:text, JSON.generate(frame))
           rescue => e
             Clacky::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
@@ -341,19 +360,7 @@ module Clacky
             end
           end
 
-          # Wraps a raw socket for websocket-driver client mode.
-          class SocketWrapper
-            attr_reader :url
 
-            def initialize(socket, url)
-              @socket = socket
-              @url = url
-            end
-
-            def write(data)
-              @socket.write(data)
-            end
-          end
         end
       end
     end

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

@@ -37,7 +37,10 @@ module Clacky
           # Raised for non-zero API return codes or HTTP errors.
           class ApiError < StandardError
             attr_reader :code
-            def initialize(code, msg) = (@code = code; super("WeixinApiError(#{code}): #{msg.to_s.slice(0, 200)}"))
+            def initialize(code, msg)
+              @code = code
+              super("WeixinApiError(#{code}): #{msg.to_s.slice(0, 200)}")
+            end
           end
 
           # Raised on network/read timeouts.

data/lib/clacky/server/channel/channel_config.rb

@@ -38,7 +38,7 @@ module Clacky
     # @return [ChannelConfig]
     def self.load(config_file = CONFIG_FILE)
       if File.exist?(config_file)
-        data = YAML.safe_load(File.read(config_file), permitted_classes: [Symbol]) || {}
+        data = YAMLCompat.safe_load(File.read(config_file), permitted_classes: [Symbol]) || {}
       else
         data = {}
       end

data/lib/clacky/server/http_server.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 require "webrick"
-require "websocket/driver"
+require "websocket"
 require "json"
 require "thread"
 require "fileutils"
@@ -75,7 +75,7 @@ module Clacky
 
       # Ignore all other UI methods (progress, errors, etc.) during history replay
       def method_missing(name, *args, **kwargs); end
-      def respond_to_missing?(name, include_private = false) = true
+      def respond_to_missing?(name, include_private = false); true; end
     end
 
     # HttpServer runs an embedded WEBrick HTTP server with WebSocket support.
@@ -559,6 +559,23 @@ module Clacky
           return
         end
 
+        # Send heartbeat if interval has elapsed (once per day)
+        if brand.heartbeat_due?
+          Clacky::Logger.info("[Brand] api_brand_status: heartbeat due, sending...")
+          result = brand.heartbeat!
+          if result[:success]
+            Clacky::Logger.info("[Brand] api_brand_status: heartbeat OK")
+          else
+            Clacky::Logger.warn("[Brand] api_brand_status: heartbeat failed — #{result[:message]}")
+          end
+          # Reload after heartbeat to pick up updated expires_at / last_heartbeat
+          brand = Clacky::BrandConfig.load
+        else
+          Clacky::Logger.debug("[Brand] api_brand_status: heartbeat not due yet")
+        end
+
+        Clacky::Logger.debug("[Brand] api_brand_status: expired=#{brand.expired?} grace_exceeded=#{brand.grace_period_exceeded?} expires_at=#{brand.license_expires_at&.iso8601 || "nil"}")
+
         warning = nil
         if brand.expired?
           warning = "Your #{brand.product_name} license has expired. Please renew to continue."
@@ -571,6 +588,8 @@ module Clacky
           end
         end
 
+        Clacky::Logger.debug("[Brand] api_brand_status: warning=#{warning.inspect}")
+
         json_response(res, 200, {
           branded:          true,
           needs_activation: false,
@@ -1579,26 +1598,27 @@ module Clacky
         req["Upgrade"]&.downcase == "websocket"
       end
 
-      # Hijacks the TCP socket from WEBrick and hands it to websocket-driver.
+      # Hijacks the TCP socket from WEBrick and upgrades it to WebSocket.
       def handle_websocket(req, res)
-        # Prevent WEBrick from closing the socket after this handler returns
         socket = req.instance_variable_get(:@socket)
 
-        driver = WebSocket::Driver.rack(
-          RackEnvAdapter.new(req, socket),
-          max_length: 10 * 1024 * 1024
-        )
+        # Server handshake — parse the upgrade request
+        handshake = WebSocket::Handshake::Server.new
+        handshake << build_handshake_request(req)
+        unless handshake.finished? && handshake.valid?
+          $stderr.puts "WebSocket handshake invalid"
+          return
+        end
 
-        conn = WebSocketConnection.new(socket, driver)
+        # Send the 101 Switching Protocols response
+        socket.write(handshake.to_s)
 
-        driver.on(:open)    { on_ws_open(conn) }
-        driver.on(:message) { |event| on_ws_message(conn, event.data) }
-        driver.on(:close)   { on_ws_close(conn) }
-        driver.on(:error)   { |event| $stderr.puts "WS error: #{event.message}" }
+        version  = handshake.version
+        incoming = WebSocket::Frame::Incoming::Server.new(version: version)
+        conn     = WebSocketConnection.new(socket, version)
 
-        driver.start
+        on_ws_open(conn)
 
-        # Read loop — blocks this thread until the socket closes
         begin
           buf = String.new("", encoding: "BINARY")
           loop do
@@ -1609,14 +1629,27 @@ module Clacky
             when nil
               break  # EOF
             else
-              driver.parse(chunk)
+              incoming << chunk.dup
+              while (frame = incoming.next)
+                case frame.type
+                when :text
+                  on_ws_message(conn, frame.data)
+                when :binary
+                  on_ws_message(conn, frame.data)
+                when :ping
+                  conn.send_raw(:pong, frame.data)
+                when :close
+                  conn.send_raw(:close, "")
+                  break
+                end
+              end
             end
           end
         rescue IOError, Errno::ECONNRESET, Errno::EPIPE
           # Client disconnected
         ensure
           on_ws_close(conn)
-          driver.close rescue nil
+          socket.close rescue nil
         end
 
         # Tell WEBrick not to send any response (we handled everything)
@@ -1626,6 +1659,14 @@ module Clacky
         $stderr.puts "WebSocket handler error: #{e.class}: #{e.message}"
       end
 
+      # Build a raw HTTP request string from WEBrick request for WebSocket::Handshake::Server
+      private def build_handshake_request(req)
+        lines = ["#{req.request_method} #{req.request_uri.request_uri} HTTP/1.1\r\n"]
+        req.each { |k, v| lines << "#{k}: #{v}\r\n" }
+        lines << "\r\n"
+        lines.join
+      end
+
       def on_ws_open(conn)
         @ws_mutex.synchronize { @all_ws_conns << conn }
         # Client will send a "subscribe" message to bind to a session
@@ -2040,47 +2081,34 @@ module Clacky
 
       # ── Inner classes ─────────────────────────────────────────────────────────
 
-      # Thin adapter so websocket-driver (which expects a Rack env) can work with WEBrick.
-      class RackEnvAdapter
-        def initialize(req, socket)
-          @req    = req
-          @socket = socket
-        end
-
-        def env
-          {
-            "REQUEST_METHOD" => @req.request_method,
-            "HTTP_HOST"      => @req["Host"],
-            "REQUEST_URI"    => @req.request_uri.to_s,
-            "HTTP_UPGRADE"   => @req["Upgrade"],
-            "HTTP_CONNECTION"          => @req["Connection"],
-            "HTTP_SEC_WEBSOCKET_KEY"   => @req["Sec-WebSocket-Key"],
-            "HTTP_SEC_WEBSOCKET_VERSION" => @req["Sec-WebSocket-Version"],
-            "rack.hijack"    => proc {},
-            "rack.input"     => StringIO.new
-          }
-        end
-
-        def write(data)
-          @socket.write(data)
-        end
-      end
-
-      # Wraps a raw TCP socket + WebSocket driver, providing a thread-safe send method.
+      # Wraps a raw TCP socket, providing thread-safe WebSocket frame sending.
       class WebSocketConnection
         attr_accessor :session_id
 
-        def initialize(socket, driver)
+        def initialize(socket, version)
           @socket     = socket
-          @driver     = driver
+          @version    = version
           @send_mutex = Mutex.new
         end
 
         def send_json(data)
-          @send_mutex.synchronize { @driver.text(JSON.generate(data)) }
+          send_raw(:text, JSON.generate(data))
         rescue => e
           $stderr.puts "WS send error: #{e.message}"
         end
+
+        def send_raw(type, data)
+          @send_mutex.synchronize do
+            outgoing = WebSocket::Frame::Outgoing::Server.new(
+              version: @version,
+              data: data,
+              type: type
+            )
+            @socket.write(outgoing.to_s)
+          end
+        rescue => e
+          $stderr.puts "WS send_raw error: #{e.message}"
+        end
       end
     end
   end

data/lib/clacky/server/scheduler.rb

@@ -244,7 +244,7 @@ module Clacky
       private def load_schedules
         return [] unless File.exist?(SCHEDULES_FILE)
 
-        data = YAML.load_file(SCHEDULES_FILE, permitted_classes: [Symbol])
+        data = YAMLCompat.load_file(SCHEDULES_FILE, permitted_classes: [Symbol])
         Array(data)
       rescue => e
         Clacky::Logger.error("scheduler_load_schedules_error", error: e)

data/lib/clacky/tools/browser.rb

@@ -234,7 +234,7 @@ module Clacky
       end
 
       private def browser_enabled?
-        config = YAML.safe_load(File.read(BROWSER_CONFIG_PATH), permitted_classes: [Date, Time, Symbol])
+        config = YAMLCompat.safe_load(File.read(BROWSER_CONFIG_PATH), permitted_classes: [Date, Time, Symbol])
         config.is_a?(Hash) && config["enabled"] == true
       end
 

data/lib/clacky/ui2/ui_controller.rb

@@ -945,6 +945,9 @@ module Clacky
 
           handle_key(key)
         end
+      rescue Clacky::AgentInterrupted
+        # Ctrl+C raised AgentInterrupted on main thread — stop silently
+        stop
       rescue => e
         stop
         raise e

data/lib/clacky/utils/parser_manager.rb

@@ -72,11 +72,14 @@ module Clacky
 
         stdout, stderr, status = Open3.capture3(RbConfig.ruby, parser_path, file_path)
 
+        # Filter out Ruby/Bundler version warnings that pollute stderr
+        clean_stderr = stderr.lines.reject { |l| l.match?(/warning:|already initialized constant/) }.join.strip
+
         if status.success? && stdout.strip.length > 0
           { success: true, text: stdout.strip, error: nil, parser_path: parser_path }
         else
           { success: false, text: nil,
-            error: stderr.strip.empty? ? "Parser exited with code #{status.exitstatus}" : stderr.strip,
+            error: clean_stderr.empty? ? "Parser exited with code #{status.exitstatus}" : clean_stderr,
             parser_path: parser_path }
         end
       end

data/lib/clacky/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Clacky
-  VERSION = "0.9.11"
+  VERSION = "0.9.13"
 end

data/lib/clacky.rb

@@ -1,5 +1,56 @@
 # frozen_string_literal: true
 
+# ── Ruby < 2.7 polyfills ──────────────────────────────────────────────────────
+
+# Enumerable#filter_map was added in Ruby 2.7.
+if RUBY_VERSION < "2.7"
+  module Enumerable
+    def filter_map(&block)
+      return to_enum(:filter_map) unless block
+
+      each_with_object([]) do |item, result|
+        mapped = block.call(item)
+        result << mapped if mapped
+      end
+    end
+  end
+end
+
+# File.absolute_path? was added in Ruby 2.7.
+# Polyfill: a path is absolute if it starts with "/" (Unix) or a drive letter (Windows).
+unless File.respond_to?(:absolute_path?)
+  def File.absolute_path?(path)
+    File.expand_path(path) == path.to_s
+  end
+end
+
+# URI.encode_uri_component was added in Ruby 3.2.
+# CGI.escape encodes spaces as '+'; replace with '%20' to match URI encoding.
+require "uri"
+require "cgi"
+unless URI.respond_to?(:encode_uri_component)
+  def URI.encode_uri_component(str)
+    CGI.escape(str.to_s).gsub("+", "%20")
+  end
+end
+
+# YAML.safe_load with permitted_classes: keyword was added in Psych 4 (Ruby 3.1).
+# On older Ruby, the second positional argument serves the same purpose.
+# This helper provides a unified interface across Ruby versions.
+module YAMLCompat
+  def self.safe_load(yaml_string, permitted_classes: [])
+    if Psych::VERSION >= "4.0"
+      YAML.safe_load(yaml_string, permitted_classes: permitted_classes)
+    else
+      YAML.safe_load(yaml_string, permitted_classes)
+    end
+  end
+
+  def self.load_file(path, permitted_classes: [])
+    safe_load(File.read(path), permitted_classes: permitted_classes)
+  end
+end
+
 require_relative "clacky/version"
 require_relative "clacky/message_format/anthropic"
 require_relative "clacky/message_format/open_ai"