openclacky 0.9.12 → 0.9.13

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 791fa59b1013c559e294b373e1a7ba671545eef76ae7037ed3c604ed9f269b45
-  data.tar.gz: 8ffae20491125d886e36387b811f9ea8c2e2fcc76d76d10e08224bcc06a93972
+  metadata.gz: d21f7af79e1b66e118c909432e379375359e2bf650099c7bd17669985411409b
+  data.tar.gz: 1f927c5ce98c2560773cd0a8011ef0d523c56788fe47e17aec3dc1f952d1cd5c
 SHA512:
-  metadata.gz: 6895348aeef5d8ed713273a2d386e390a018e5b4991c37a7fd20b7fdbb4782fc945779b45556f31cb2a0894f78df72efc80ad4661b3b95d89cd8ab0c333b65a0
-  data.tar.gz: 01c35bb0a3377b81c4e3f89892d58b10472f9611347ed9b0478872e76e3c236def6b499475df32d6020c56fe94dcd33c11495512ee94a5a44a1c81aefbaaad3e
+  metadata.gz: a3a51590171a24e10a002d9c89ff5a46e17ff2b09080553e886f156ab53b9dca3a64050a80816678cdd8510c1aa3fe0158732139e07053503c366ddf17e8ea9d
+  data.tar.gz: 7c76475762cf8ecf506337ec80fb6aa12eac582d604f8245c801e1c6d89bea7d32f7e508e689a8a1f6bc6ed3f7ec9f7a2ce85682ffb33954d8e6e2178c1def1f

data/CHANGELOG.md

@@ -7,6 +7,16 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.9.13] - 2026-03-27
+
+### Added
+- **Ruby 2.6 compatibility**: the gem now installs cleanly on Ruby 2.6 (including macOS system Ruby 2.6.x) — dependency version constraints for `faraday` and `rouge` are now capped so RubyGems automatically selects compatible versions on older Ruby environments
+
+### Fixed
+- **WebSocket pure-Ruby replacement**: replaced the native WebSocket dependency with a pure-Ruby implementation to improve cross-platform compatibility
+- **Ctrl+C warning in UI suppressed**: fixed a spurious warning printed to the terminal when pressing Ctrl+C in the interactive UI
+- **Parser stderr pollution from Bundler warnings filtered**: Ruby/Bundler version warnings no longer contaminate parser error messages
+
 ## [0.9.12] - 2026-03-27
 
 ### Added

data/lib/clacky/brand_config.rb

@@ -102,16 +102,28 @@ module Clacky
 
     # Returns true when a heartbeat should be sent (interval elapsed).
     def heartbeat_due?
-      return true if @license_last_heartbeat.nil?
+      if @license_last_heartbeat.nil?
+        Clacky::Logger.debug("[Brand] heartbeat_due? => true (never sent)")
+        return true
+      end
 
-      (Time.now.utc - @license_last_heartbeat) >= HEARTBEAT_INTERVAL
+      elapsed = Time.now.utc - @license_last_heartbeat
+      due = elapsed >= HEARTBEAT_INTERVAL
+      Clacky::Logger.debug("[Brand] heartbeat_due? elapsed=#{elapsed.to_i}s interval=#{HEARTBEAT_INTERVAL}s => #{due}")
+      due
     end
 
     # Returns true when the grace period for missed heartbeats has expired.
     def grace_period_exceeded?
-      return false if @license_last_heartbeat.nil?
+      if @license_last_heartbeat.nil?
+        Clacky::Logger.debug("[Brand] grace_period_exceeded? => false (no heartbeat recorded)")
+        return false
+      end
 
-      (Time.now.utc - @license_last_heartbeat) >= HEARTBEAT_GRACE_PERIOD
+      elapsed = Time.now.utc - @license_last_heartbeat
+      exceeded = elapsed >= HEARTBEAT_GRACE_PERIOD
+      Clacky::Logger.debug("[Brand] grace_period_exceeded? elapsed=#{elapsed.to_i}s grace=#{HEARTBEAT_GRACE_PERIOD}s => #{exceeded}")
+      exceeded
     end
 
     # Returns true when the license is bound to a specific user (user_id present).
@@ -221,7 +233,12 @@ module Clacky
     # Send a heartbeat to the API and update last_heartbeat timestamp.
     # Returns a result hash: { success: bool, message: String }
     def heartbeat!
-      return { success: false, message: "License not activated" } unless activated?
+      unless activated?
+        Clacky::Logger.debug("[Brand] heartbeat! skipped — license not activated")
+        return { success: false, message: "License not activated" }
+      end
+
+      Clacky::Logger.info("[Brand] heartbeat! sending — last_heartbeat=#{@license_last_heartbeat&.iso8601 || "nil"} expires_at=#{@license_expires_at&.iso8601 || "nil"}")
 
       user_id   = parse_user_id_from_key(@license_key)
       key_hash  = Digest::SHA256.hexdigest(@license_key)
@@ -246,8 +263,10 @@ module Clacky
         @license_expires_at = parse_time(response[:data]["expires_at"]) if response[:data]["expires_at"]
         apply_distribution(response[:data]["distribution"])
         save
+        Clacky::Logger.info("[Brand] heartbeat! success — expires_at=#{@license_expires_at&.iso8601} last_heartbeat=#{@license_last_heartbeat.iso8601}")
         { success: true, message: "Heartbeat OK" }
       else
+        Clacky::Logger.warn("[Brand] heartbeat! failed — #{response[:error]}")
         { success: false, message: response[:error] || "Heartbeat failed" }
       end
     end

data/lib/clacky/cli.rb

@@ -252,12 +252,16 @@ module Clacky
         brand = Clacky::BrandConfig.load
         return unless brand.branded?
 
+        Clacky::Logger.info("[Brand] check_brand_license_cli: activated=#{brand.activated?} expired=#{brand.expired?} expires_at=#{brand.license_expires_at&.iso8601 || "nil"} last_heartbeat=#{brand.license_last_heartbeat&.iso8601 || "nil"}")
+
         unless brand.activated?
+          Clacky::Logger.info("[Brand] check_brand_license_cli: not activated, prompting user")
           cli_prompt_license_activation(brand)
           return
         end
 
         if brand.expired?
+          Clacky::Logger.warn("[Brand] check_brand_license_cli: license expired at #{brand.license_expires_at&.iso8601}")
           say ""
           say "WARNING: Your #{brand.product_name} license has expired. Please renew to continue.", :yellow
           say ""
@@ -265,17 +269,25 @@ module Clacky
         end
 
         if brand.heartbeat_due?
+          Clacky::Logger.info("[Brand] check_brand_license_cli: heartbeat due, sending...")
           result = brand.heartbeat!
-          unless result[:success]
-            if brand.grace_period_exceeded?
-              say ""
-              say "WARNING: Could not reach the #{brand.product_name} license server.", :yellow
-              say "License has been offline for more than 3 days. Please check your connection.", :yellow
-              say ""
-            else
-              say "(License heartbeat failed - will retry tomorrow.)", :cyan
+          if result[:success]
+            Clacky::Logger.info("[Brand] check_brand_license_cli: heartbeat OK")
+          else
+            Clacky::Logger.warn("[Brand] check_brand_license_cli: heartbeat failed — #{result[:message]} grace_exceeded=#{brand.grace_period_exceeded?}")
+            unless result[:success]
+              if brand.grace_period_exceeded?
+                say ""
+                say "WARNING: Could not reach the #{brand.product_name} license server.", :yellow
+                say "License has been offline for more than 3 days. Please check your connection.", :yellow
+                say ""
+              else
+                say "(License heartbeat failed - will retry tomorrow.)", :cyan
+              end
             end
           end
+        else
+          Clacky::Logger.debug("[Brand] check_brand_license_cli: heartbeat not due yet")
         end
       end
 

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/http_server.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 require "webrick"
-require "websocket/driver"
+require "websocket"
 require "json"
 require "thread"
 require "fileutils"
@@ -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/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.12"
+  VERSION = "0.9.13"
 end