openclacky 0.9.28 → 0.9.30

data/lib/clacky/deploy_api_client.rb

@@ -0,0 +1,484 @@
+# frozen_string_literal: true
+
+require "faraday"
+require "json"
+
+module Clacky
+  # DeployApiClient - Encapsulates all Deploy API calls for the Railway deployment flow.
+  #
+  # All endpoints use Workspace API Key (clacky_ak_*) authentication, as the backend
+  # supports both clacky_ak_* and clacky_dk_* for all deploy endpoints.
+  #
+  # Usage:
+  #   client = DeployApiClient.new("clacky_ak_xxx", base_url: "https://api.clacky.ai")
+  #
+  #   # Check payment status
+  #   result = client.payment_status(project_id: "proj_abc")
+  #   # => { success: true, is_paid: true }
+  #
+  #   # Create a deploy task
+  #   result = client.create_task(project_id: "proj_abc")
+  #   # => { success: true, deploy_task_id: "...", platform_token: "...", ... }
+  #
+  #   # Poll services until DB is ready
+  #   result = client.services(deploy_task_id: "task_abc")
+  #   # => { success: true, services: [...], domain_name: "..." }
+  #
+  #   # Poll deploy status
+  #   result = client.deploy_status(deploy_task_id: "task_abc")
+  #   # => { success: true, status: "SUCCESS", url: "https://..." }
+  #
+  #   # Bind domain
+  #   result = client.bind_domain(deploy_task_id: "task_abc")
+  #   # => { success: true, domain: "my-app.example.com" }
+  #
+  #   # Notify backend of deploy outcome
+  #   client.notify(project_id: "...", deploy_task_id: "...", status: "success")
+  class DeployApiClient
+    BASE_PATH        = "/openclacky/v1"
+    REQUEST_TIMEOUT  = 30   # seconds for normal requests
+    OPEN_TIMEOUT     = 10   # seconds for connection
+
+    def initialize(workspace_key, base_url:)
+      @workspace_key = workspace_key.to_s.strip
+      @base_url      = base_url.to_s.strip.sub(%r{/+$}, "")
+    end
+
+    # -------------------------------------------------------------------------
+    # Payment
+    # -------------------------------------------------------------------------
+
+    # Query whether the project has an active paid subscription.
+    #
+    # @param project_id [String]
+    # @return [Hash] { success: true, is_paid: Boolean } or { success: false, error: String }
+    def payment_status(project_id:)
+      response = connection.get("#{BASE_PATH}/deploy/payment") do |req|
+        req.params["project_id"] = project_id
+      end
+
+      return http_error(response) unless response.status == 200
+
+      body = parse_body(response)
+      return body_error(body) unless success_code?(body)
+
+      data = body["data"] || {}
+      { success: true, is_paid: data["is_paid"] == true }
+    rescue Faraday::Error => e
+      { success: false, error: "Network error: #{e.message}" }
+    rescue => e
+      { success: false, error: "Unexpected error: #{e.message}" }
+    end
+
+    # -------------------------------------------------------------------------
+    # Regions
+    # -------------------------------------------------------------------------
+
+    # Fetch the list of supported deployment regions.
+    #
+    # @param project_id [String] Required by the backend to scope region availability.
+    # @return [Hash] {
+    #   success: true,
+    #   regions: Array<Hash>  # e.g. [{ "id" => "us-west", "name" => "US West", "label" => "US West (Oregon)" }, ...]
+    # } or { success: false, error: String }
+    def regions(project_id:)
+      response = connection.get("#{BASE_PATH}/deploy/regions") do |req|
+        req.params["project_id"] = project_id
+      end
+
+      return http_error(response) unless response.status == 200
+
+      body = parse_body(response)
+      return body_error(body) unless success_code?(body)
+
+      data = body["data"] || {}
+      list = data["regions"] || data || []
+      list = list.values if list.is_a?(Hash)
+      { success: true, regions: Array(list) }
+    rescue Faraday::Error => e
+      { success: false, error: "Network error: #{e.message}" }
+    rescue => e
+      { success: false, error: "Unexpected error: #{e.message}" }
+    end
+
+    # -------------------------------------------------------------------------
+    # Create Deploy Task
+    # -------------------------------------------------------------------------
+
+    # Create a new deployment task on the backend. Returns Railway credentials.
+    #
+    # @param project_id [String]
+    # @param backup_db  [Boolean] default false
+    # @param env_vars   [Hash]    extra env vars to pass at task creation time
+    # @param region     [String]  optional Railway region slug
+    # @return [Hash] {
+    #   success: true,
+    #   deploy_task_id:         String,
+    #   deploy_service_id:      String,
+    #   platform_token:         String,   # RAILWAY_TOKEN
+    #   platform_project_id:    String,
+    #   platform_environment_id: String
+    # }
+    def create_task(project_id:, backup_db: false, env_vars: {}, region: nil)
+      body_params = { project_id: project_id, backup_db: backup_db }
+      body_params[:env_vars] = env_vars unless env_vars.empty?
+      body_params[:region]   = region   if region
+
+      response = connection.post("#{BASE_PATH}/deploy/create-task") do |req|
+        req.headers["Content-Type"] = "application/json"
+        req.body = JSON.generate(body_params)
+      end
+
+      return http_error(response) unless response.status == 200
+
+      body = parse_body(response)
+      return body_error(body) unless success_code?(body)
+
+      data = body["data"] || {}
+      {
+        success:                 true,
+        deploy_task_id:          data["deploy_task_id"],
+        deploy_service_id:       data["deploy_service_id"],
+        platform_token:          data["platform_token"],
+        platform_project_id:     data["platform_project_id"],
+        platform_environment_id: data["platform_environment_id"]
+      }
+    rescue Faraday::Error => e
+      { success: false, error: "Network error: #{e.message}" }
+    rescue => e
+      { success: false, error: "Unexpected error: #{e.message}" }
+    end
+
+    # -------------------------------------------------------------------------
+    # Services (poll for middleware readiness)
+    # -------------------------------------------------------------------------
+
+    # Query all services under a deploy task.
+    # Used to wait for the PostgreSQL middleware to reach status SUCCESS
+    # before injecting the DATABASE_URL reference.
+    #
+    # @param deploy_task_id [String]
+    # @return [Hash] {
+    #   success: true,
+    #   services:    Array<Hash>,   # full service objects from API
+    #   domain_name: String,        # assigned domain (may be empty on first call)
+    #   db_service:  Hash | nil     # first middleware service with status SUCCESS
+    # }
+    def services(deploy_task_id:)
+      url = "#{BASE_PATH}/deploy/services?deploy_task_id=#{deploy_task_id}"
+      puts "  [DEBUG API] GET #{@base_url}#{url}"
+      
+      response = connection.get("#{BASE_PATH}/deploy/services") do |req|
+        req.params["deploy_task_id"] = deploy_task_id
+      end
+
+      puts "  [DEBUG API] Response status: #{response.status}"
+      
+      return http_error(response) unless response.status == 200
+
+      body = parse_body(response)
+      puts "  [DEBUG API] Response body: #{body.inspect[0..500]}..." if body
+      
+      return body_error(body) unless success_code?(body)
+
+      data     = body["data"] || {}
+      svcs     = data["services"] || []
+      domain   = data["domain_name"].to_s
+
+      # Debug: print detailed service info
+      puts "  [DEBUG] Total services returned: #{svcs.size}"
+      svcs.each_with_index do |s, idx|
+        puts "  [DEBUG]   Service[#{idx}]: name=#{s['service_name']}, type=#{s['type']}, status=#{s['status']}"
+        if s["type"] == "middleware"
+          env_vars = s["env_vars"] || {}
+          puts "  [DEBUG]     - env_vars keys: #{env_vars.keys.join(', ')}"
+          puts "  [DEBUG]     - has DATABASE_URL: #{env_vars.key?('DATABASE_URL')}"
+          puts "  [DEBUG]     - has DATABASE_PUBLIC_URL: #{env_vars.key?('DATABASE_PUBLIC_URL')}"
+        end
+      end
+
+      # Find first middleware (DB) that is fully provisioned
+      db_svc = svcs.find do |s|
+        s["type"] == "middleware" && s["status"]&.upcase == "SUCCESS"
+      end
+      
+      puts "  [DEBUG] db_svc found: #{!db_svc.nil?}"
+      if db_svc
+        puts "  [DEBUG]   - db_svc name: #{db_svc['service_name']}"
+        puts "  [DEBUG]   - db_svc status: #{db_svc['status']}"
+      end
+
+      # middleware_support: { supported: Boolean, supported_types: Array }
+      # When supported == false, no DB middleware will be provisioned by Clacky.
+      # The deploy script uses this to skip the DB polling loop entirely.
+      middleware_support = data["middleware_support"] || {}
+      puts "  [DEBUG] middleware_support: #{middleware_support.inspect}"
+
+      # platform_bucket_credentials contains S3-compatible storage credentials.
+      # Passed through so the deploy script can inject STORAGE_BUCKET_* env vars.
+      bucket_credentials = data["platform_bucket_credentials"]
+      bucket_name        = data["platform_bucket_name"].to_s
+
+      {
+        success:              true,
+        services:             svcs,
+        domain_name:          domain,
+        db_service:           db_svc,
+        middleware_support:   middleware_support,
+        bucket_credentials:   bucket_credentials,
+        bucket_name:          bucket_name
+      }
+    rescue Faraday::Error => e
+      { success: false, error: "Network error: #{e.message}" }
+    rescue => e
+      { success: false, error: "Unexpected error: #{e.message}" }
+    end
+
+    # -------------------------------------------------------------------------
+    # Deploy Status
+    # -------------------------------------------------------------------------
+
+    # Query the real-time deployment status for a task.
+    #
+    # @param deploy_task_id [String]
+    # @return [Hash] {
+    #   success: true,
+    #   status:  String,   # SUCCESS / FAILED / CRASHED / DEPLOYING / WAITING
+    #   url:     String
+    # }
+    def deploy_status(deploy_task_id:)
+      response = connection.get("#{BASE_PATH}/deploy/status") do |req|
+        req.params["deploy_task_id"] = deploy_task_id
+      end
+
+      return http_error(response) unless response.status == 200
+
+      body = parse_body(response)
+      return body_error(body) unless success_code?(body)
+
+      data = body["data"] || {}
+      {
+        success: true,
+        status:  data["status"].to_s.upcase,
+        url:     data["url"].to_s,
+        deploy_service_id: data["deploy_service_id"].to_s
+      }
+    rescue Faraday::Error => e
+      { success: false, error: "Network error: #{e.message}" }
+    rescue => e
+      { success: false, error: "Unexpected error: #{e.message}" }
+    end
+
+    # -------------------------------------------------------------------------
+    # Bind Domain
+    # -------------------------------------------------------------------------
+
+    # Bind a custom domain to the deploy task.
+    #
+    # @param deploy_task_id [String]
+    # @return [Hash] { success: true, domain: String } or { success: false, error: String }
+    def bind_domain(deploy_task_id:)
+      response = connection.post("#{BASE_PATH}/deploy/bind-domain") do |req|
+        req.headers["Content-Type"] = "application/json"
+        req.body = JSON.generate({ deploy_task_id: deploy_task_id })
+      end
+
+      return http_error(response) unless response.status == 200
+
+      body = parse_body(response)
+      return body_error(body) unless success_code?(body)
+
+      data = body["data"] || {}
+      { success: true, domain: data["domain"].to_s }
+    rescue Faraday::Error => e
+      { success: false, error: "Network error: #{e.message}" }
+    rescue => e
+      { success: false, error: "Unexpected error: #{e.message}" }
+    end
+
+    # -------------------------------------------------------------------------
+    # Build Logs
+    # -------------------------------------------------------------------------
+
+    # Fetch build logs for a deploy task (synchronous, not SSE).
+    #
+    # @param deploy_task_id [String]
+    # @param service_id [String, nil] optional service ID filter
+    # @param level [String] log level filter ("INFO", "ERROR", "WARN", etc.)
+    # @param lines [Integer] maximum number of lines to return (default: 100)
+    # @return [Hash] {
+    #   success: true,
+    #   logs: Array<Hash>  # [{ "timestamp" => ..., "level" => "INFO", "message" => "..." }, ...]
+    # } or { success: false, error: String }
+    def build_logs(deploy_task_id:, service_id: nil, level: "INFO", lines: 100)
+      body_params = {
+        deploy_task_id: deploy_task_id,
+        level: level,
+        lines: lines
+      }
+      body_params[:service_id] = service_id if service_id
+
+      response = connection.post("#{BASE_PATH}/tasks/logs") do |req|
+        req.headers["Content-Type"] = "application/json"
+        req.body = JSON.generate(body_params)
+      end
+
+      return http_error(response) unless response.status == 200
+
+      body = parse_body(response)
+      return body_error(body) unless success_code?(body)
+
+      data = body["data"] || {}
+      logs = data["logs"] || []
+      { success: true, logs: logs }
+    rescue Faraday::Error => e
+      { success: false, error: "Network error: #{e.message}" }
+    rescue => e
+      { success: false, error: "Unexpected error: #{e.message}" }
+    end
+
+    # Stream build logs using SSE (Server-Sent Events).
+    # This method yields each log line as it arrives.
+    #
+    # @param deploy_task_id [String]
+    # @param service_id [String, nil] optional service ID filter
+    # @param level [String] log level filter ("INFO", "ERROR", "WARN", etc.)
+    # @yield [Hash] each log event: { "type" => "log", "timestamp" => ..., "message" => "..." }
+    # @return [Hash] { success: true } or { success: false, error: String }
+    def stream_build_logs(deploy_task_id:, service_id: nil, level: "INFO", &block)
+      require "net/http"
+      require "openssl"
+
+      body_params = {
+        deploy_task_id: deploy_task_id,
+        level: level
+      }
+      body_params[:service_id] = service_id if service_id
+
+      url = "#{@base_url}#{BASE_PATH}/tasks/stream/build-logs"
+      uri = URI.parse(url)
+
+      Net::HTTP.start(uri.host, uri.port, use_ssl: uri.scheme == "https", verify_mode: OpenSSL::SSL::VERIFY_NONE) do |http|
+        request = Net::HTTP::Post.new(uri.path)
+        request["Authorization"] = "Bearer #{@workspace_key}"
+        request["Accept"] = "text/event-stream"
+        request["Content-Type"] = "application/json"
+        request.body = JSON.generate(body_params)
+
+        http.request(request) do |response|
+          return { success: false, error: "HTTP #{response.code}: #{response.message}" } unless response.code.to_i == 200
+
+          buffer = ""
+          response.read_body do |chunk|
+            buffer << chunk
+            while (line_end = buffer.index("\n"))
+              line = buffer.slice!(0..line_end).strip
+              next if line.empty? || !line.start_with?("data:")
+
+              json_str = line.sub(/^data:\s*/, "")
+              begin
+                event = JSON.parse(json_str)
+                block.call(event) if block
+              rescue JSON::ParserError
+                # Ignore malformed JSON
+              end
+            end
+          end
+        end
+      end
+
+      { success: true }
+    rescue => e
+      { success: false, error: "Stream error: #{e.message}" }
+    end
+
+    # -------------------------------------------------------------------------
+    # Notify
+    # -------------------------------------------------------------------------
+
+    # Notify the backend of the current deployment outcome.
+    # Fire-and-forget — failures are logged but do not raise.
+    #
+    # @param project_id        [String]
+    # @param deploy_task_id    [String]
+    # @param deploy_service_id [String] optional
+    # @param status            [String] "deploying" | "success" | "failed"
+    # @param message           [String] optional description
+    # @param target_port       [Integer] default 3000
+    # @return [Hash] { success: true } or { success: false, error: String }
+    def notify(project_id:, deploy_task_id:, status:,
+               deploy_service_id: nil, message: nil, target_port: nil)
+      payload = {
+        project_id:     project_id,
+        deploy_task_id: deploy_task_id,
+        status:         status
+      }
+      payload[:deploy_service_id] = deploy_service_id if deploy_service_id
+      payload[:message]           = message           if message
+      payload[:target_port]       = target_port       if target_port
+
+      response = connection.post("#{BASE_PATH}/deploy/notify") do |req|
+        req.headers["Content-Type"] = "application/json"
+        req.body = JSON.generate(payload)
+      end
+
+      return http_error(response) unless response.status == 200
+
+      body = parse_body(response)
+      return body_error(body) unless success_code?(body)
+
+      { success: true }
+    rescue => e
+      # Notify failures are non-fatal — log and move on
+      warn "[deploy_api] notify failed: #{e.message}"
+      { success: false, error: e.message }
+    end
+
+    # -------------------------------------------------------------------------
+    # Private helpers
+    # -------------------------------------------------------------------------
+
+    private def connection
+      @connection ||= Faraday.new(url: @base_url) do |f|
+        f.options.timeout      = REQUEST_TIMEOUT
+        f.options.open_timeout = OPEN_TIMEOUT
+        f.headers["Authorization"] = "Bearer #{@workspace_key}"
+        f.headers["Accept"]        = "application/json"
+        # Disable SSL verification to avoid OpenSSL certificate path issues
+        # on some macOS environments with system Ruby
+        f.ssl.verify = false
+        f.adapter Faraday.default_adapter
+      end
+    end
+
+    private def parse_body(response)
+      JSON.parse(response.body)
+    rescue JSON::ParserError
+      nil
+    end
+
+    private def success_code?(body)
+      return false if body.nil?
+
+      code = body["code"].to_i
+      code == 0 || code == 200
+    end
+
+    private def http_error(response)
+      msg = begin
+        parsed = JSON.parse(response.body)
+        parsed["message"] || parsed["msg"] || response.body.to_s[0, 200]
+      rescue
+        response.body.to_s[0, 200]
+      end
+      { success: false, error: "HTTP #{response.status}: #{msg}" }
+    end
+
+    private def body_error(body)
+      return { success: false, error: "Invalid JSON response from API" } if body.nil?
+
+      msg = body["message"] || body["msg"] || "Unknown API error (code: #{body["code"]})"
+      { success: false, error: msg }
+    end
+  end
+end

data/lib/clacky/json_ui_controller.rb

@@ -97,10 +97,6 @@ module Clacky
       emit("info", message: message)
     end
 
-    def show_idle_status(phase:, message:)
-      emit("idle_status", phase: phase.to_s, message: message)
-    end
-
     def show_warning(message)
       emit("warning", message: message)
     end
@@ -119,15 +115,25 @@ module Clacky
 
     # === Progress ===
 
-    def show_progress(message = nil, prefix_newline: true, output_buffer: nil)
-      @progress_start_time = Time.now
-      emit("progress", message: message, status: "start")
+    def show_progress(message = nil, prefix_newline: true, progress_type: "thinking", phase: "active", metadata: {})
+      @progress_start_time = Time.now if phase == "active"
+      
+      data = {
+        message: message,
+        progress_type: progress_type,
+        phase: phase,
+        status: phase == "active" ? "start" : "stop"  # backward compat
+      }
+      data[:metadata] = metadata unless metadata.empty?
+      data[:elapsed] = (Time.now - @progress_start_time).round(1) if phase == "done" && @progress_start_time
+      
+      emit("progress", **data)
+      
+      @progress_start_time = nil if phase == "done"
     end
 
     def clear_progress
-      elapsed = @progress_start_time ? (Time.now - @progress_start_time).round(1) : 0
-      @progress_start_time = nil
-      emit("progress", status: "stop", elapsed: elapsed)
+      show_progress(progress_type: "thinking", phase: "done")
     end
 
     # === State updates ===

data/lib/clacky/message_format/bedrock.rb

@@ -17,11 +17,12 @@ module Clacky
     # This module converts canonical format ↔ Bedrock Converse API format.
     module Bedrock
       # Detect if the request should use the Bedrock Converse API.
-      # Matches either:
+      # Matches any of:
       #   - API key with "ABSK" prefix (native AWS Bedrock)
+      #   - API key with "clacky-" prefix (Clacky workspace key, proxied via Bedrock Converse)
       #   - Model ID with "abs-" prefix (Clacky AI proxy that speaks Bedrock Converse)
       def self.bedrock_api_key?(api_key, model)
-        api_key.to_s.start_with?("ABSK") || model.to_s.start_with?("abs-")
+        api_key.to_s.start_with?("ABSK", "clacky-") || model.to_s.start_with?("abs-")
       end
 
       module_function

data/lib/clacky/message_history.rb

@@ -12,6 +12,7 @@ module Clacky
       task_id created_at system_injected session_context memory_update
       subagent_instructions subagent_result token_usage
       compressed_summary chunk_path truncated transient
+      chunk_index chunk_count
     ].freeze
 
     def initialize(messages = [])
@@ -123,6 +124,13 @@ module Clacky
       msg&.dig(:session_date)
     end
 
+    # Return the chunk_count from the most recently injected chunk index message.
+    # Used by inject_chunk_index_if_needed to avoid re-injecting when nothing changed.
+    def last_injected_chunk_count
+      msg = @messages.reverse.find { |m| m[:chunk_index] }
+      msg&.dig(:chunk_count) || 0
+    end
+
     # Return only real (non-system-injected) user messages.
     def real_user_messages
       @messages.select { |m| m[:role] == "user" && !m[:system_injected] }

data/lib/clacky/plain_ui_controller.rb

@@ -87,11 +87,6 @@ module Clacky
       puts_line("[info] #{message}")
     end
 
-    def show_idle_status(phase:, message:)
-      # In plain mode, just print the final state
-      puts_line("[info] #{message}") if phase.to_s == "end"
-    end
-
     def show_warning(message)
       puts_line("[warn] #{message}")
     end
@@ -111,7 +106,7 @@ module Clacky
 
     # === Progress (no-ops — no spinner in plain mode) ===
 
-    def show_progress(message = nil, prefix_newline: true, output_buffer: nil); end
+    def show_progress(message = nil, prefix_newline: true, progress_type: "thinking", phase: "active", metadata: {}); end
     def clear_progress; end
 
     # === State updates (no-ops) ===

data/lib/clacky/providers.rb

@@ -11,13 +11,31 @@ module Clacky
     # - api: API type (anthropic-messages, openai-responses, openai-completions)
     # - default_model: Recommended default model
     PRESETS = {
+      "openclacky" => {
+        "name" => "OpenClacky",
+        "base_url" => "https://api.openclacky.com",
+        "api" => "bedrock",
+        "default_model" => "abs-claude-sonnet-4-5",
+        "lite_model" => "abs-claude-haiku-4-5",
+        "models" => [
+          "abs-claude-opus-4-6",
+          "abs-claude-sonnet-4-6",
+          "abs-claude-sonnet-4-5",
+          "abs-claude-haiku-4-5"
+        ],
+        # Fallback chain: if a model is unavailable, try the next one in order.
+        # Keys are primary model names; values are the fallback model to use instead.
+        "fallback_models" => {
+          "abs-claude-sonnet-4-6" => "abs-claude-sonnet-4-5"
+        },
+        "website_url" => "https://www.openclacky.com/ai-keys"
+      }.freeze,
 
       "openrouter" => {
         "name" => "OpenRouter",
         "base_url" => "https://openrouter.ai/api/v1",
         "api" => "openai-responses",
         "default_model" => "anthropic/claude-sonnet-4-6",
-        "lite_model" => "anthropic/claude-haiku-4-5",
         "models" => [],  # Dynamic - fetched from API
         "website_url" => "https://openrouter.ai/keys"
       }.freeze,
@@ -49,15 +67,16 @@ module Clacky
         "website_url" => "https://console.anthropic.com/settings/keys"
       }.freeze,
 
-      "clackyai" => {
-        "name" => "ClackyAI",
+      "clackyai-sea" => {
+        "name" => "ClackyAI( Sea )",
         "base_url" => "https://api.clacky.ai",
         "api" => "bedrock",
-        "default_model" => "abs-claude-sonnet-4-6",
+        "default_model" => "abs-claude-sonnet-4-5",
         "lite_model" => "abs-claude-haiku-4-5",
         "models" => [
           "abs-claude-opus-4-6",
           "abs-claude-sonnet-4-6",
+          "abs-claude-sonnet-4-5",
           "abs-claude-haiku-4-5"
         ],
         # Fallback chain: if a model is unavailable, try the next one in order.

data/lib/clacky/server/browser_manager.rb

@@ -237,7 +237,9 @@ module Clacky
       cmd = build_mcp_command(detected)
       Clacky::Logger.info("[BrowserManager] Starting MCP daemon: #{cmd.join(' ')}")
       
-      stdin, stdout, stderr_io, wait_thr = Open3.popen3(*cmd)
+      # close_others: true prevents inheriting the server's listening socket (port 7070).
+      # The MCP daemon is an independent external process and should not hold server fds.
+      stdin, stdout, stderr_io, wait_thr = Open3.popen3(*cmd, close_others: true)
       Thread.new { stderr_io.read rescue nil }
 
       # MCP handshake

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

@@ -130,7 +130,8 @@ module Clacky
             end
           rescue EOFError, IOError, Errno::ECONNRESET, Errno::EPIPE,
                  Errno::ETIMEDOUT, OpenSSL::SSL::SSLError => e
-            Clacky::Logger.warn("[feishu-ws] Connection lost (#{e.class}: #{e.message}), reconnecting in #{RECONNECT_DELAY}s...")
+            # Let the exception bubble up to start() where it will log and sleep before retry
+            raise
           ensure
             @ws_open = false
             @ws_socket = nil

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

@@ -361,7 +361,9 @@ module Clacky
 
             send_frame(cmd: cmd, req_id: req_id, body: body)
 
-            result = queue.pop(timeout: 30)
+            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")