openclacky 0.9.34 → 0.9.35

data/lib/clacky/idle_compression_timer.rb

@@ -84,6 +84,14 @@ module Clacky
       @mutex.synchronize { @timer_thread&.alive? || @compress_thread&.alive? }
     end
 
+    # True only when compression work is actually in flight (not during the
+    # pre-compression idle countdown). Used by callers that want to treat
+    # Ctrl+C during active compression as "stop compressing" rather than
+    # "exit the program".
+    def compressing?
+      @mutex.synchronize { @compress_thread&.alive? || false }
+    end
+
     private def run_compression
       success = @agent.trigger_idle_compression
 

data/lib/clacky/json_ui_controller.rb

@@ -134,10 +134,11 @@ module Clacky
 
     # === State updates ===
 
-    def update_sessionbar(tasks: nil, cost: nil, status: nil)
+    def update_sessionbar(tasks: nil, cost: nil, cost_source: nil, status: nil)
       data = {}
       data[:tasks] = tasks if tasks
       data[:cost] = cost if cost
+      data[:cost_source] = cost_source if cost_source
       data[:status] = status if status
       emit("session_update", **data) unless data.empty?
     end

data/lib/clacky/plain_ui_controller.rb

@@ -43,9 +43,16 @@ module Clacky
       end
 
       display = case name
-                when "shell", "safe_shell"
+                when "terminal"
                   cmd = args_data.is_a?(Hash) ? (args_data[:command] || args_data["command"]) : args_data
-                  "$ #{cmd}"
+                  sid = args_data.is_a?(Hash) ? (args_data[:session_id] || args_data["session_id"]) : nil
+                  if cmd
+                    "$ #{cmd}"
+                  elsif sid
+                    "$ (session ##{sid})"
+                  else
+                    "$ terminal"
+                  end
                 when "write"
                   path = args_data.is_a?(Hash) ? (args_data[:path] || args_data["path"]) : args_data
                   "Write → #{path}"
@@ -129,7 +136,7 @@ module Clacky
 
     # === State updates (no-ops) ===
 
-    def update_sessionbar(tasks: nil, cost: nil, status: nil); end
+    def update_sessionbar(tasks: nil, cost: nil, cost_source: nil, status: nil); end
     def update_todos(todos); end
     def set_working_status; end
     def set_idle_status; end

data/lib/clacky/platform_http_client.rb

@@ -3,6 +3,7 @@
 require "net/http"
 require "uri"
 require "json"
+require "fileutils"
 
 module Clacky
   # PlatformHttpClient provides a resilient HTTP client for all calls to the
@@ -12,6 +13,8 @@ module Clacky
   #   - Automatic retry with exponential back-off on transient failures
   #   - Transparent domain failover: if the primary domain times out or returns a
   #     5xx error, the request is automatically retried against the fallback domain
+  #   - Unified large-file download entry point (#download_file) that reuses the
+  #     same primary → fallback failover policy as API calls
   #   - Override via CLACKY_LICENSE_SERVER env var (used in development)
   #
   # Usage:
@@ -29,9 +32,13 @@ module Clacky
     ATTEMPTS_PER_HOST = 2
     # Initial back-off between retries within the same domain (seconds)
     INITIAL_BACKOFF   = 0.5
-    # Connection / read timeouts (seconds)
+    # Connection / read timeouts (seconds) for API calls
     OPEN_TIMEOUT  = 8
     READ_TIMEOUT  = 15
+    # Read timeout for streaming large file downloads (seconds)
+    DOWNLOAD_READ_TIMEOUT = 120
+    # Max HTTP redirects followed by #download_file per host attempt
+    DOWNLOAD_MAX_REDIRECTS = 10
 
     # API error code → human-readable message table (shared across all callers)
     API_ERROR_MESSAGES = {
@@ -108,6 +115,159 @@ module Clacky
                             read_timeout_override: read_timeout)
     end
 
+    # Stream a remote URL to a local file path, with automatic primary → fallback
+    # host failover.
+    #
+    # This is the unified entry point for all large-file downloads (brand skill
+    # ZIPs, platform-hosted assets, etc.). Callers should NOT build their own
+    # Net::HTTP loops — failover, retry, redirects, and timeouts are handled here.
+    #
+    # Host failover policy:
+    #   - If +url+'s host matches PRIMARY_HOST and the request fails with a
+    #     retryable error (timeout, connection reset, SSL, 5xx), the URL is
+    #     rewritten to FALLBACK_HOST (same path/query) and retried.
+    #   - Both hosts serve the same Rails backend and share +secret_key_base+,
+    #     so ActiveStorage signed_ids resolve identically on either.
+    #   - Third-party hosts (e.g. S3 presigned URLs reached via redirect) are
+    #     fetched as-is without host rewriting.
+    #
+    # Each host gets ATTEMPTS_PER_HOST attempts with exponential back-off.
+    # Up to DOWNLOAD_MAX_REDIRECTS redirects are followed per attempt.
+    #
+    # @param url  [String]   Full URL to download
+    # @param dest [String]   Local path to write the response body into.
+    #                        The file is written atomically (temp path + rename)
+    #                        so a failed download cannot leave a half-written file.
+    # @param read_timeout [Integer] Override read timeout (seconds)
+    # @return [Hash] { success: Boolean, bytes: Integer, error: String }
+    def download_file(url, dest, read_timeout: DOWNLOAD_READ_TIMEOUT)
+      candidate_urls = [url]
+      # Only auto-add a fallback candidate when the URL is on our primary host.
+      # External hosts (S3, CDNs, user-provided URLs) are fetched as-is.
+      if primary_host_url?(url)
+        candidate_urls << swap_to_fallback_host(url)
+      end
+
+      last_error = nil
+      FileUtils.mkdir_p(File.dirname(dest))
+      tmp_dest = "#{dest}.part"
+
+      candidate_urls.each_with_index do |candidate, host_index|
+        ATTEMPTS_PER_HOST.times do |attempt|
+          begin
+            bytes = stream_download(candidate, tmp_dest, read_timeout: read_timeout)
+            File.rename(tmp_dest, dest)
+            return { success: true, bytes: bytes, error: nil }
+          rescue RetryableNetworkError => e
+            last_error = e
+            backoff    = INITIAL_BACKOFF * (2**attempt)
+            Clacky::Logger.debug(
+              "[PlatformHTTP] DOWNLOAD #{candidate} attempt #{attempt + 1} failed: " \
+              "#{e.message} — retrying in #{backoff}s"
+            )
+            sleep(backoff)
+          end
+        end
+
+        if host_index + 1 < candidate_urls.size
+          Clacky::Logger.debug(
+            "[PlatformHTTP] Primary host exhausted for download, switching to fallback: " \
+            "#{candidate_urls[host_index + 1]}"
+          )
+        end
+      end
+
+      FileUtils.rm_f(tmp_dest)
+      { success: false, bytes: 0, error: "Download failed: #{last_error&.message || "unknown"}" }
+    end
+
+    # True when +url+ targets the primary platform host.
+    # Used by #download_file to decide whether fallback-host rewriting is safe.
+    private def primary_host_url?(url)
+      return false if url.nil? || url.empty?
+
+      uri = URI.parse(url)
+      primary = URI.parse(PRIMARY_HOST)
+      uri.host == primary.host
+    rescue URI::InvalidURIError
+      false
+    end
+
+    # Rewrite +url+ so its host is the fallback domain (same path + query).
+    # Callers must have already confirmed the URL's host is PRIMARY_HOST via
+    # #primary_host_url? — this method does not validate that precondition.
+    private def swap_to_fallback_host(url)
+      uri      = URI.parse(url)
+      fallback = URI.parse(FALLBACK_HOST)
+      uri.scheme = fallback.scheme
+      uri.host   = fallback.host
+      # Only apply an explicit port when fallback declares a non-default one
+      uri.port = fallback.port if fallback.port && fallback.port != fallback.default_port
+      uri.to_s
+    end
+
+    # Execute a streaming GET with redirect following, writing the response body
+    # to +dest+ as it arrives. Raises RetryableNetworkError on any transient
+    # failure so the caller can decide whether to retry / failover.
+    #
+    # @return [Integer] Number of bytes written
+    private def stream_download(url, dest, read_timeout:)
+      current_url = url
+      DOWNLOAD_MAX_REDIRECTS.times do
+        uri  = URI.parse(current_url)
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl      = uri.scheme == "https"
+        http.open_timeout = OPEN_TIMEOUT
+        http.read_timeout = read_timeout
+
+        req = Net::HTTP::Get.new(uri.request_uri)
+
+        written = 0
+        redirect_to = nil
+        http.start do |h|
+          h.request(req) do |resp|
+            case resp.code.to_i
+            when 200
+              File.open(dest, "wb") do |f|
+                resp.read_body do |chunk|
+                  f.write(chunk)
+                  written += chunk.bytesize
+                end
+              end
+            when 301, 302, 303, 307, 308
+              location = resp["location"]
+              raise RetryableNetworkError, "Redirect with no Location header" if location.nil? || location.empty?
+
+              redirect_to = location
+            else
+              # 5xx is retryable, 4xx is terminal — but we don't have separate
+              # handling in the existing API path and fallback is still useful
+              # for e.g. upstream 502/503, so treat everything non-2xx/3xx as
+              # retryable to match the spirit of request_with_failover.
+              raise RetryableNetworkError, "HTTP #{resp.code}"
+            end
+          end
+        end
+
+        return written if redirect_to.nil?
+
+        current_url = redirect_to
+      end
+
+      raise RetryableNetworkError, "Too many redirects"
+    rescue Net::OpenTimeout, Net::ReadTimeout => e
+      raise RetryableNetworkError, "Timeout: #{e.message}"
+    rescue Errno::ECONNREFUSED, Errno::EHOSTUNREACH, Errno::ENETUNREACH,
+           Errno::ECONNRESET, EOFError => e
+      raise RetryableNetworkError, "Connection error: #{e.message}"
+    rescue OpenSSL::SSL::SSLError => e
+      raise RetryableNetworkError, "SSL error: #{e.message}"
+    rescue RetryableNetworkError
+      raise
+    rescue StandardError => e
+      raise RetryableNetworkError, e.message
+    end
+
     private def request_with_failover(method, path, payload, extra_headers, read_timeout_override: nil)
       last_error = nil
 

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

@@ -167,10 +167,12 @@ module Clacky
 
         Clacky::Logger.info("[ChannelManager] Routing to session #{session_id[0, 8]} (status=#{session[:status]})")
 
+        # If session is running, interrupt it automatically (mimics CLI behavior)
         if session[:status] == :running
-          Clacky::Logger.info("[ChannelManager] Session busy, rejecting message")
-          adapter.send_text(event[:chat_id], "Still working on the previous task. Send `/stop` to interrupt.")
-          return
+          Clacky::Logger.info("[ChannelManager] Session busy, interrupting previous task")
+          @interrupt_session.call(session_id)
+          # Wait briefly for the thread to catch the interrupt and update status
+          sleep 0.1
         end
 
         agent  = session[:agent]

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

@@ -51,7 +51,11 @@ module Clacky
       def show_assistant_message(content, files:)
         flush_buffer
         Clacky::Logger.info("[ChannelUI] show_assistant_message files=#{files.size} content_len=#{content.to_s.length}")
-        send_text(content) unless content.nil? || content.to_s.strip.empty?
+        # Strip file:// markdown links from the text sent to IM channels —
+        # the actual files are delivered via send_file() below, so the
+        # raw markdown links would just be noise in the chat.
+        text = content.to_s.gsub(/!?\[[^\]]*\]\(file:\/\/[^)]+\)/, "").strip
+        send_text(text) unless text.empty?
         files.each do |f|
           Clacky::Logger.info("[ChannelUI] sending file path=#{f[:path].inspect} name=#{f[:name].inspect}")
           send_file(f[:path], f[:name])
@@ -144,7 +148,7 @@ module Clacky
 
       # === State updates (no-ops for IM) ===
 
-      def update_sessionbar(tasks: nil, cost: nil, status: nil); end
+      def update_sessionbar(tasks: nil, cost: nil, cost_source: nil, status: nil); end
       def update_todos(todos); end
       def set_working_status; end
       def set_idle_status; end