openclacky 1.2.9 → 1.2.10

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

@@ -300,12 +300,31 @@ module Clacky
               return { message_id: nil }
             end
 
+            text = sanitize_for_weixin(text)
             return { message_id: nil } if text.strip.empty?
 
             @send_queue.enqueue(chat_id, text, ctoken)
             { message_id: nil }
           end
 
+          private def sanitize_for_weixin(text)
+            s = text.to_s
+            s = s.gsub(/^[ \t]{0,3}>[ \t]?/, "")
+            s = s.gsub(/\*\*([^\n*][^*]*?)\*\*/m) { Regexp.last_match(1) }
+            s = s.gsub(/`([^`\n]+)`/) { Regexp.last_match(1) }
+            s = s.gsub(/^[ \t]{0,3}\#{1,6}[ \t]+/, "")
+            s
+          end
+
+          private def sanitize_file_name_for_weixin(name)
+            ext = File.extname(name.to_s)
+            stem = File.basename(name.to_s, ext)
+            stem = stem.tr("&<>\"'\/", "_")
+            stem = stem.gsub(/[\x00-\x1f]/, "_").strip
+            stem = "file" if stem.empty?
+            "#{stem}#{ext}"
+          end
+
           # Force-flush pending text for a chat_id. Called before sending files or on task completion.
           def flush_pending(chat_id)
             @send_queue.flush(chat_id)
@@ -321,17 +340,20 @@ module Clacky
               return { message_id: nil }
             end
 
+            display_name = name || File.basename(file_path)
+            safe_name = sanitize_file_name_for_weixin(display_name)
+
             @send_queue.flush(chat_id)
 
             @api_client.send_file(
               to_user_id:    chat_id,
               file_path:     file_path,
-              file_name:     name || File.basename(file_path),
+              file_name:     safe_name,
               context_token: ctoken
             )
             { message_id: nil }
           rescue => e
-            Clacky::Logger.error("[WeixinAdapter] send_file failed for #{chat_id}: #{e.message}")
+            Clacky::Logger.error("[WeixinAdapter] send_file failed for #{chat_id}: #{e.class}: #{e.message}")
             { message_id: nil }
           end
 

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

@@ -58,6 +58,9 @@ module Clacky
 
         Clacky::Logger.info("[ChannelManager] Starting channels: #{enabled_platforms.join(", ")}")
         @running = true
+
+        restore_channel_bindings
+
         enabled_platforms.each { |platform| start_adapter(platform) }
       end
 
@@ -240,7 +243,11 @@ module Clacky
         end
 
         session_id = resolve_session(event)
-        session_id = auto_create_session(adapter, event) unless session_id
+        if session_id
+          bind_key_to_session(channel_key(event), session_id)
+        else
+          session_id = auto_create_session(adapter, event)
+        end
 
         session = @registry.get(session_id)
         unless session
@@ -263,8 +270,13 @@ module Clacky
         agent  = session[:agent]
         web_ui = session[:ui]
 
+        # Set channel info on the agent so session context includes platform/sender.
+        agent.channel_info = extract_channel_info(event) if agent.respond_to?(:channel_info=)
+
+        # Re-attach channel UI if it was dropped (session was evicted from memory and rebuilt by ensure).
+        ensure_channel_ui_subscribed(session_id, event)
+
         # Update reply context so responses thread under the current message.
-        # channel_ui is bound to the session for its full lifetime (created in auto_create_session).
         channel_ui_for_session(session_id)&.update_message_context(event)
 
         # Sync the inbound message to WebUI so it shows up in the browser session.
@@ -499,6 +511,16 @@ module Clacky
           found = nil
           @registry.with_session(summary[:id]) { |s| found = s[:channel_keys]&.include?(key) }
           return summary[:id] if found
+
+          # Check evicted channel sessions via persisted channel_info
+          next unless summary[:source] == "channel"
+          next unless @registry.ensure(summary[:id])
+          agent = nil
+          @registry.with_session(summary[:id]) { |s| agent = s[:agent] }
+          next unless agent&.channel_info
+          next unless channel_key_from_info(agent.channel_info) == key
+          bind_key_to_session(key, summary[:id])
+          return summary[:id]
         end
         nil
       rescue StandardError => e
@@ -534,6 +556,24 @@ module Clacky
         result
       end
 
+      # Make sure session has a ChannelUIController subscribed to its WebUIController.
+      # Needed both at startup (for restored sessions) and after a session is evicted
+      # from memory and rebuilt by SessionRegistry#ensure (which drops :ui/:channel_ui).
+      def ensure_channel_ui_subscribed(session_id, event)
+        needs_attach = false
+        @registry.with_session(session_id) do |s|
+          needs_attach = s[:ui] && s[:channel_ui].nil?
+        end
+        return unless needs_attach
+
+        channel_ui = ChannelUIController.new(event, -> { adapter_for(event[:platform]) })
+        @registry.with_session(session_id) do |s|
+          next unless s[:ui] && s[:channel_ui].nil?
+          s[:ui].subscribe_channel(channel_ui)
+          s[:channel_ui] = channel_ui
+        end
+      end
+
       def web_ui_for_session_diag(session_id)
         result = nil
         @registry.with_session(session_id) do |s|
@@ -581,6 +621,27 @@ module Clacky
         end
       end
 
+      def channel_key_from_info(channel_info)
+        platform = channel_info[:platform].to_s
+        chat_id  = channel_info[:chat_id].to_s
+        user_id  = channel_info[:user_id].to_s
+        case @binding_mode
+        when :chat      then "#{platform}:chat:#{chat_id}"
+        when :user      then "#{platform}:user:#{user_id}"
+        else # :chat_user (default)
+          "#{platform}:chat:#{chat_id}:user:#{user_id}"
+        end
+      end
+
+      private def extract_channel_info(event)
+        {
+          platform:  event[:platform],
+          user_id:   event[:user_id],
+          user_name: event[:user_name],
+          chat_id:   event[:chat_id]
+        }
+      end
+
       # Extract the chat_id from the remainder of a channel_key (after removing "platform:" prefix).
       #
       # Possible formats:
@@ -604,6 +665,32 @@ module Clacky
         end
       end
 
+      def restore_channel_bindings
+        bound_keys = Set.new
+        restored_count = 0
+        @registry.list(limit: nil).each do |summary|
+          @registry.ensure(summary[:id])
+          agent = nil
+          @registry.with_session(summary[:id]) { |s| agent = s[:agent] }
+          next unless agent&.channel_info
+
+          info = agent.channel_info
+          next unless info[:platform] && info[:user_id] && info[:chat_id]
+
+          key = channel_key_from_info(info)
+
+          event = { platform: info[:platform], chat_id: info[:chat_id] }
+          ensure_channel_ui_subscribed(summary[:id], event)
+
+          next unless bound_keys.add?(key)
+          bind_key_to_session(key, summary[:id])
+
+          Clacky::Logger.info("[ChannelManager] Restored channel binding #{key} -> session #{summary[:id][0, 8]}")
+          restored_count += 1
+        end
+        Clacky::Logger.info("[ChannelManager] Restored #{restored_count} channel binding(s)") if restored_count > 0
+      end
+
       def safe_stop_adapter(adapter)
         adapter.stop
       rescue StandardError => e

data/lib/clacky/server/http_server.rb

@@ -4,6 +4,7 @@ require "webrick"
 require "websocket"
 require "socket"
 require "json"
+require "net/http"
 require "thread"
 require "fileutils"
 require "tmpdir"
@@ -107,6 +108,8 @@ module Clacky
     #   GET  /**                     → static files served from lib/clacky/web/ directory
     class HttpServer
       WEB_ROOT = File.expand_path("../web", __dir__)
+      EXCHANGE_RATE_PRIMARY_BASE_URL = "https://open.er-api.com/v6/latest"
+      EXCHANGE_RATE_FALLBACK_URL = "https://api.frankfurter.app/latest"
 
       # Default SOUL.md written when the user skips the onboard conversation.
       # A richer version is created by the Agent during the soul_setup phase.
@@ -368,6 +371,8 @@ module Clacky
           90
         elsif path == "/api/tool/browser"
           30
+        elsif path == "/api/exchange-rate"
+          20
         elsif path.end_with?("/benchmark")
           20
         elsif path == "/api/media/image"
@@ -401,6 +406,7 @@ module Clacky
         when ["GET",    "/api/skills"]         then api_list_skills(res)
         when ["GET",    "/api/config"]        then api_get_config(res)
         when ["GET",    "/api/config/settings"]  then api_get_settings(res)
+        when ["GET",    "/api/exchange-rate"]    then api_exchange_rate(req, res)
         when ["PATCH",  "/api/config/settings"]  then api_update_settings(req, res)
         when ["POST",   "/api/config/models"] then api_add_model(req, res)
         when ["POST",   "/api/config/test"]   then api_test_config(req, res)
@@ -656,6 +662,103 @@ module Clacky
         end
       end
 
+      # GET /api/exchange-rate?from=USD&to=CNY
+      # Fetches the latest exchange rate on demand. The browser still owns the
+      # saved preference in localStorage; this API is only a lightweight proxy
+      # that avoids CORS issues and normalizes provider responses.
+      def api_exchange_rate(req, res)
+        query = URI.decode_www_form(req.query_string.to_s).to_h
+        from  = normalize_currency_code(query["from"], fallback: "USD")
+        to    = normalize_currency_code(query["to"], fallback: "CNY")
+
+        unless from && to
+          return json_response(res, 400, { error: "from and to must be 3-letter currency codes" })
+        end
+
+        data = fetch_exchange_rate(from, to)
+        json_response(res, 200, data)
+      rescue StandardError => e
+        Clacky::Logger.warn("[ExchangeRate] failed: #{e.class}: #{e.message}")
+        json_response(res, 502, { error: "Failed to fetch exchange rate" })
+      end
+
+      def normalize_currency_code(value, fallback:)
+        code = value.to_s.strip.upcase
+        code = fallback if code.empty?
+        code.match?(/\A[A-Z]{3}\z/) ? code : nil
+      end
+
+      def fetch_exchange_rate(from, to)
+        fetch_open_exchange_rate(from, to)
+      rescue StandardError => primary_error
+        Clacky::Logger.warn("[ExchangeRate] primary source failed: #{primary_error.message}")
+        fetch_frankfurter_exchange_rate(from, to)
+      end
+
+      def fetch_open_exchange_rate(from, to)
+        data = fetch_exchange_rate_json("#{EXCHANGE_RATE_PRIMARY_BASE_URL}/#{URI.encode_www_form_component(from)}")
+        raise "open.er-api.com returned #{data["result"] || "unknown"}" unless data["result"] == "success"
+
+        rate = positive_float(data.dig("rates", to))
+        raise "open.er-api.com missing #{to} rate" unless rate
+
+        updated_at = data["time_last_update_utc"].to_s
+        {
+          from: from,
+          to: to,
+          rate: rate,
+          date: parse_exchange_rate_date(updated_at),
+          updated_at: updated_at,
+          source: "open.er-api.com"
+        }
+      end
+
+      def fetch_frankfurter_exchange_rate(from, to)
+        query = URI.encode_www_form("from" => from, "to" => to)
+        data  = fetch_exchange_rate_json("#{EXCHANGE_RATE_FALLBACK_URL}?#{query}")
+
+        rate = positive_float(data.dig("rates", to))
+        raise "frankfurter.app missing #{to} rate" unless rate
+
+        {
+          from: from,
+          to: to,
+          rate: rate,
+          date: data["date"].to_s,
+          updated_at: data["date"].to_s,
+          source: "frankfurter.app"
+        }
+      end
+
+      def fetch_exchange_rate_json(url)
+        uri = URI(url)
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = uri.scheme == "https"
+        http.open_timeout = 5
+        http.read_timeout = 8
+
+        req = Net::HTTP::Get.new(uri.request_uri, "Accept" => "application/json")
+        response = http.request(req)
+        raise "HTTP #{response.code}" unless response.is_a?(Net::HTTPSuccess)
+
+        JSON.parse(response.body.to_s)
+      end
+
+      def positive_float(value)
+        rate = Float(value)
+        rate.positive? ? rate : nil
+      rescue ArgumentError, TypeError
+        nil
+      end
+
+      def parse_exchange_rate_date(value)
+        return "" if value.to_s.strip.empty?
+
+        Date.parse(value.to_s).iso8601
+      rescue ArgumentError
+        ""
+      end
+
       # ── Onboard API ───────────────────────────────────────────────────────────
 
       # GET /api/onboard/status
@@ -2649,16 +2752,28 @@ module Clacky
         root = File.expand_path(agent.working_dir.to_s)
         return json_response(res, 404, { error: "Working directory not found" }) unless Dir.exist?(root)
 
-        rel = URI.decode_www_form(req.query_string.to_s).to_h["path"].to_s
-        rel = rel.sub(%r{\A/+}, "").strip
-        target = File.expand_path(File.join(root, rel))
+        query = URI.decode_www_form(req.query_string.to_s).to_h
+        rel = query["path"].to_s
+        absolute_mode = query["absolute"] == "true"
+
+        # Absolute mode: allow browsing outside working directory (e.g., root "/")
+        if absolute_mode
+          target = File.expand_path(rel.empty? ? "/" : rel)
+          display_root = target
+          # Normalize rel for API response
+          rel = target
+        else
+          rel = rel.sub(%r{\A/+}, "").strip
+          target = File.expand_path(File.join(root, rel))
+          display_root = root
 
-        # Reject traversal outside the working directory.
-        unless target == root || target.start_with?("#{root}/")
-          return json_response(res, 403, { error: "Path outside working directory" })
+          # Reject traversal outside the working directory.
+          unless target == root || target.start_with?("#{root}/")
+            return json_response(res, 403, { error: "Path outside working directory" })
+          end
         end
-        return json_response(res, 404, { error: "Directory not found" }) unless Dir.exist?(target)
 
+        return json_response(res, 404, { error: "Directory not found" }) unless Dir.exist?(target)
         entries = Dir.children(target).reject { |name| IGNORED_FILE_ENTRIES.include?(name) }
 
         items = entries.filter_map do |name|
@@ -2668,7 +2783,7 @@ module Clacky
           next unless File.exist?(full)
           {
             name:  name,
-            path:  rel.empty? ? name : "#{rel}/#{name}",
+            path:  "#{rel}/#{name}".gsub(%r{/+}, "/"),
             type:  is_dir ? "dir" : "file",
             size:  is_dir ? nil : (File.size(full) rescue nil)
           }
@@ -2679,7 +2794,7 @@ module Clacky
         # Directories first, then files; both case-insensitive alphabetical.
         items.sort_by! { |it| [it[:type] == "dir" ? 0 : 1, it[:name].downcase] }
 
-        json_response(res, 200, { root: root, path: rel, entries: items })
+        json_response(res, 200, { root: display_root, path: rel, entries: items })
       rescue StandardError => e
         json_response(res, 500, { error: e.message })
       end

data/lib/clacky/session_manager.rb

@@ -179,16 +179,17 @@ module Clacky
       deleted
     end
 
-    # Keep only the most recent N sessions by created_at; delete the rest.
-    # Returns count of deleted sessions.
+    # Keep only the most recent N non-pinned sessions by created_at; the rest
+    # are soft-deleted (moved to the session trash, recoverable). Pinned
+    # sessions are never deleted and do not count toward the cap.
+    # Returns count of soft-deleted sessions.
     def cleanup_by_count(keep:)
-      sessions = all_sessions # already sorted newest-first
-      return 0 if sessions.size <= keep
+      non_pinned = all_sessions.reject { |s| s[:pinned] } # already sorted newest-first
+      return 0 if non_pinned.size <= keep
 
-      sessions[keep..].each do |session|
-        filepath = File.join(@sessions_dir, generate_filename(session[:session_id], session[:created_at]))
-        _hard_delete_session_with_chunks(filepath) if File.exist?(filepath)
-      end.size
+      victims = non_pinned[keep..]
+      victims.each { |session| soft_delete(session[:session_id]) }
+      victims.size
     end
 
     # ── Session trash (delegates to Tools::TrashManager) ──────────────

data/lib/clacky/telemetry.rb

@@ -42,7 +42,8 @@ module Clacky
           os:            RbConfig::CONFIG["host_os"],
           ruby_version:  RUBY_VERSION,
           brand:         brand.branded? ? brand.package_name : nil,
-          launch_source: LAUNCH_SOURCES.fetch(ENV["CLACKY_LAUNCHED_BY"], "cli")
+          launch_source: LAUNCH_SOURCES.fetch(ENV["CLACKY_LAUNCHED_BY"], "cli"),
+          container:     detect_container
         }.compact
 
         fire_and_forget("/api/v1/telemetry/startup", payload)
@@ -62,7 +63,8 @@ module Clacky
         payload = {
           device_id: resolve_device_id(brand),
           version:   Clacky::VERSION,
-          brand:     brand.branded? ? brand.package_name : nil
+          brand:     brand.branded? ? brand.package_name : nil,
+          container: detect_container
         }
         payload.merge!(extract_task_metrics(result)) if result.is_a?(Hash)
 
@@ -80,6 +82,18 @@ module Clacky
         brand.device_id
       end
 
+      private def detect_container
+        return "docker" if File.exist?("/.dockerenv")
+
+        begin
+          cgroup = File.read("/proc/1/cgroup")
+          return "docker" if cgroup.include?("docker") || cgroup.include?("containerd")
+        rescue Errno::ENOENT, Errno::EACCES
+          nil
+        end
+        nil
+      end
+
       private def extract_task_metrics(result)
         cache = result[:cache_stats] || {}
         duration = result[:duration_seconds]

data/lib/clacky/ui2/layout_manager.rb

@@ -381,15 +381,19 @@ module Clacky
         render_all
       end
 
-      def cleanup_screen
+      def cleanup_screen(clear_screen: false)
         @render_mutex.synchronize do
-          fixed_start = fixed_area_start_row
-          (fixed_start...screen.height).each do |row|
-            screen.move_cursor(row, 0)
-            screen.clear_line
+          if clear_screen
+            screen.clear_screen(mode: :reset)
+          else
+            fixed_start = fixed_area_start_row
+            (fixed_start...screen.height).each do |row|
+              screen.move_cursor(row, 0)
+              screen.clear_line
+            end
+            screen.move_cursor([@output_row, 0].max, 0)
+            print "\r"
           end
-          screen.move_cursor([@output_row, 0].max, 0)
-          print "\r"
           screen.show_cursor
           screen.flush
         end

data/lib/clacky/ui2/ui_controller.rb

@@ -150,9 +150,9 @@ module Clacky
       end
 
       # Stop the UI controller
-      def stop
+      def stop(clear_screen: false)
         @running = false
-        @layout.cleanup_screen
+        @layout.cleanup_screen(clear_screen: clear_screen)
       end
 
       # Clear the input area

data/lib/clacky/ui_interface.rb

@@ -135,6 +135,6 @@ module Clacky
 
     # === Path redaction (for encrypted brand skill tmpdirs) ===
     # === Lifecycle ===
-    def stop; end
+    def stop(clear_screen: false); end
   end
 end