openclacky 1.2.2 → 1.2.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cfaa1f45ce6ab05b0a101571f59e809d92430ee862196b21a714ceb56c3ec8b5
-  data.tar.gz: 6d76cd4d7bf8568fd8229dc9770f23fb027296c660ad0ba3d514be61df69c5ce
+  metadata.gz: 80e1b5549b0e55760ec4e0e905eea3ab50bc9a66bd8c256e628a1afdb8531ba0
+  data.tar.gz: 54142ef66c3b74d3998214202fa73618dd9b22ebdb06586c8d6896aafcb56d9d
 SHA512:
-  metadata.gz: aa5e444bc28d570022df63172027028d99224191f6d2a0b26537cb5c1597c523b165b35efd58747312586aa01f133c522b5c9cae46b5f25d06501b1a083b6e31
-  data.tar.gz: ae1d58c07b9a24937b1c4182e19a093394565fdc972c5caf72cba66f3bf0419cbdd0874f7b2d741d7b00b8efdd8fe83a2efee767f7df1a3e8e6656b237631721
+  metadata.gz: d69d02391cc1929d26f2cfc2a260d27cb6b1f6840c254ae67f7ad358f621ba16eb2476fd5cee28308f7eaf2e0eb21d5983b49de4f84c6905863292625644641a
+  data.tar.gz: 54dbeb6d31f187edc30ea4e6030776e988cf50ee7ed44a2177a77473d00c47ae358df25dfd9bd526ea93126b94733feaca5a63048cde8657201c4c1e7cd05edd

data/CHANGELOG.md

@@ -5,6 +5,42 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [1.2.4] - 2026-05-27
+
+### Added
+- Browser/agent snapshot now supports `with_page` for paginated results
+- Prefer WSL1 over WSL2 for better compatibility
+
+### Fixed
+- Feishu post message type and WeCom mixed message type not handled properly
+- WeChat stale QR code session not detected when reconfiguring channel
+- Channel adapter using stale reference after reconfiguration
+- Benchmark terminated early by 10-second outer request timeout
+- Model card action buttons overflowing on narrow viewports
+- Save button staying disabled when reopening model edit modal
+- WSL pipe breaking when `redirect_exe_stdin` appends `</dev/null`
+- MCP registry not hot-reloading after writing config
+- MCP server breaking from bashrc PS1 customization
+- Terminal realtime output not streaming correctly
+- PowerShell UTF-8 encoding issues
+- WSL bashrc not loading in non-interactive shells
+- Qwen 3.7 Max incorrectly treated as vision-capable model
+
+### More
+- Log service start failure reason for easier diagnostics
+
+## [1.2.3] - 2026-05-27
+
+### Added
+- Qwen 3.7 model support
+- WSL network doctor PowerShell script
+- Limit on glob/grep file walker to prevent excessive traversal
+
+### Fixed
+- Terminal single-line mode issue
+- Terminal execution hang
+- apt try logic
+
 ## [1.2.2] - 2026-05-25
 
 ### More

data/lib/clacky/agent.rb

@@ -910,6 +910,17 @@ module Clacky
           # Inject working_dir so tools don't rely on Dir.chdir global state
           args[:working_dir] = @working_dir if @working_dir
 
+          # For terminal: stream live stdout chunks to the UI as they arrive,
+          # so the user sees real-time output (e.g. build logs) instead of a
+          # blank spinner. The UI buffers lines for Ctrl+O fullscreen view
+          # (CLI) and emits tool_stdout WS events (WebUI) that the browser
+          # appends to the running .tool-item.
+          if call[:name] == "terminal" && @ui.respond_to?(:show_tool_stdout)
+            args[:on_output] = ->(chunk) {
+              @ui.show_tool_stdout([chunk])
+            }
+          end
+
           # Show progress immediately for every tool execution so the user
           # always knows the agent is working. Using +with_progress+ wraps
           # the execution in an +ensure+ block so the spinner/ticker is

data/lib/clacky/client.rb

@@ -10,7 +10,7 @@ module Clacky
 
     attr_reader :provider_id
 
-    def initialize(api_key, base_url:, model:, anthropic_format: false)
+    def initialize(api_key, base_url:, model:, anthropic_format: false, read_timeout: nil)
       @api_key = api_key
       @base_url = base_url
       @model = model
@@ -38,6 +38,10 @@ module Clacky
       # Non-vision models (DeepSeek, Kimi, MiniMax, etc.) reject image_url
       # content blocks; the conversion layer strips them when this is false.
       @vision_supported = Providers.supports?(provider_id, :vision, model_name: @model)
+
+      # Optional override for Faraday read_timeout (e.g. benchmark calls).
+      # nil means use the default (300s for streaming).
+      @read_timeout = read_timeout
     end
 
     # Returns true when the client is using the AWS Bedrock Converse API.
@@ -447,7 +451,7 @@ module Clacky
       @bedrock_connection ||= Faraday.new(url: @base_url) do |conn|
         conn.headers["Content-Type"]  = "application/json"
         conn.headers["Authorization"] = "Bearer #{@api_key}"
-        conn.options.timeout      = 300
+        conn.options.timeout      = @read_timeout || 300
         conn.options.open_timeout = 10
         conn.ssl.verify           = false
         conn.adapter Faraday.default_adapter
@@ -458,7 +462,7 @@ module Clacky
       @openai_connection ||= Faraday.new(url: @base_url) do |conn|
         conn.headers["Content-Type"]  = "application/json"
         conn.headers["Authorization"] = "Bearer #{@api_key}"
-        conn.options.timeout      = 300
+        conn.options.timeout      = @read_timeout || 300
         conn.options.open_timeout = 10
         conn.ssl.verify           = false
         conn.adapter Faraday.default_adapter
@@ -494,7 +498,7 @@ module Clacky
         if @provider_id == "kimi-coding"
           conn.headers["User-Agent"] = "claude-cli/1.0.51 (external, cli)"
         end
-        conn.options.timeout      = 300
+        conn.options.timeout      = @read_timeout || 300
         conn.options.open_timeout = 10
         conn.ssl.verify           = false
         conn.adapter Faraday.default_adapter

data/lib/clacky/default_skills/browser-setup/SKILL.md

@@ -111,6 +111,96 @@ chrome-devtools-mcp --version 2>/dev/null
 
 If still missing after user confirms, stop with error message.
 
+### Step 2.5 — WSL networking setup (only when session context shows `OS: WSL/Windows`)
+
+**Skip this entire step on macOS / Linux.** Look at the session context line that begins with `[Session context: ...]` — only run this step if it includes `OS: WSL/Windows`.
+
+#### Background (read this so you know what to do)
+
+The browser tool runs inside WSL but Chrome/Edge runs on Windows. By default WSL2 uses NAT networking, which means `127.0.0.1` inside WSL **cannot** reach Windows' Chrome debug port. The fix is to enable WSL2 **mirrored networking** (`networkingMode=mirrored` in `%USERPROFILE%\.wslconfig`), which makes WSL share Windows' network stack so `127.0.0.1` works directly.
+
+We have a helper script that handles all the Windows-side details:
+
+```
+~/.clacky/scripts/wsl_network_doctor.ps1
+```
+
+It exposes three subcommands:
+
+| Subcommand | What it does | Exit code |
+|---|---|---|
+| `status` | Check whether mirrored is configured (auto-passes on WSL1) | `0` OK / `10` NEED_ENABLE |
+| `enable` | Write `networkingMode=mirrored` to `.wslconfig` (does NOT shut down WSL) | `0` success / `1` fail |
+| `repair` | Restart Windows Host Network Service (HNS) via UAC prompt | `0` launched / `1` fail |
+
+Invoke it from WSL like this:
+
+```bash
+powershell.exe -NoProfile -ExecutionPolicy Bypass -File "$(wslpath -w ~/.clacky/scripts/wsl_network_doctor.ps1)" <subcommand>
+```
+
+#### Step 2.5.1 — Check status
+
+```bash
+powershell.exe -NoProfile -ExecutionPolicy Bypass -File "$(wslpath -w ~/.clacky/scripts/wsl_network_doctor.ps1)" status
+```
+
+- Exit `0` (output starts with `OK:`) → either mirrored is configured (WSL2) or
+  Ubuntu is running on WSL1 (which shares the Windows network stack and needs no
+  config). Either way, proceed to Step 3.
+- Exit `10` (output starts with `NEED_ENABLE:`) → continue to Step 2.5.2.
+- Any other failure → show the output to the user and ask them to retry. Stop here.
+
+#### Step 2.5.2 — Enable mirrored (only when NEED_ENABLE)
+
+Tell the user what's about to happen (in their language):
+
+> WSL doesn't have mirrored networking enabled yet — the browser tool needs it to reach Chrome on Windows.
+> I'll add one line to `%USERPROFILE%\.wslconfig`. Your current WSL session will NOT be restarted.
+
+Run:
+
+```bash
+powershell.exe -NoProfile -ExecutionPolicy Bypass -File "$(wslpath -w ~/.clacky/scripts/wsl_network_doctor.ps1)" enable
+```
+
+If the script exits `0`:
+
+> ✅ `.wslconfig` updated. Tell the user (in their language):
+>
+> The config takes effect only after WSL restarts, but we can't restart WSL from inside WSL.
+> Please:
+>
+> 1. Open **PowerShell** on Windows
+> 2. Run: `wsl --shutdown`
+> 3. Reopen the Clacky terminal
+> 4. Run `/browser-setup` again
+>
+> Stop here. Wait for the user to come back in a new session.
+
+If the script exits non-zero, show the output to the user and stop. Do NOT proceed to Step 3 — without mirrored networking the browser tool will not work.
+
+#### Step 2.5.3 — When to run repair
+
+Do NOT run `repair` proactively. Only run it later if **all** of the following are true:
+
+- `status` returned `OK` (mirrored is configured)
+- The user has restarted WSL since the config was written
+- Step 3's `browser(action="status")` still fails with a "Chrome/Edge is not running or remote debugging is not enabled" error
+
+In that situation, tell the user (in their language):
+
+> The config looks correct but the browser still can't connect. Windows Host Network Service may be stuck — I'll restart it.
+> **A Windows User Account Control (UAC) prompt will appear shortly. Please click "Yes".**
+
+Then run:
+
+```bash
+powershell.exe -NoProfile -ExecutionPolicy Bypass -File "$(wslpath -w ~/.clacky/scripts/wsl_network_doctor.ps1)" repair
+```
+
+After it returns, tell the user to run `wsl --shutdown` in PowerShell and reopen Clacky. Stop and wait.
+
 ### Step 3 — Verify Chrome/Edge is running with remote debugging
 
 **CRITICAL**: Do NOT attempt `browser()` calls yet. First check if the browser is reachable using the API:

data/lib/clacky/default_skills/channel-manager/SKILL.md

@@ -341,6 +341,7 @@ Where `$QRCODE_ID` is the `qrcode_id` from Step 2's JSON output.
 
 Run this command with `timeout: 60`. If it doesn't succeed, **retry up to 3 times with the same `$QRCODE_ID`** — the QR code stays valid for 5 minutes. Only stop retrying if:
 - Exit code is 0 → success
+- Output contains "stale-session" → the qrcode_id was already consumed by a prior login; **immediately restart from Step 1** (do NOT retry with same id)
 - Output contains "expired" → QR expired, offer to restart from Step 1
 - Output contains "timed out" → offer to restart from Step 1
 - 3 retries exhausted → show error and offer to restart from Step 1

data/lib/clacky/default_skills/channel-manager/weixin_setup.rb

@@ -49,16 +49,20 @@ GIVEN_QRCODE_ID = QRCODE_ID_IDX ? ARGV[QRCODE_ID_IDX + 1] : nil
 # Logging (suppress in --fetch-qr mode so stdout is clean JSON)
 # ---------------------------------------------------------------------------
 
-def step(msg); $stderr.puts("[weixin-setup] #{msg}") unless FETCH_QR_MODE; end
-def ok(msg);   $stderr.puts("[weixin-setup] ✅ #{msg}") unless FETCH_QR_MODE; end
+WEIXIN_LOG_FILE = File.expand_path("~/.clacky/weixin_setup_debug.log")
+def wlog(msg)
+  File.open(WEIXIN_LOG_FILE, "a") { |f| f.puts("[#{Time.now.strftime("%H:%M:%S")}] #{msg}") }
+rescue StandardError
+  # ignore — debug log is best-effort
+end
+
+def step(msg); $stderr.puts("[weixin-setup] #{msg}") unless FETCH_QR_MODE; wlog(msg); end
+def ok(msg);   $stderr.puts("[weixin-setup] ✅ #{msg}") unless FETCH_QR_MODE; wlog("✅ #{msg}"); end
 
 # In fetch-qr mode, write to stderr so stdout stays clean JSON
 def log(msg)
-  if FETCH_QR_MODE
-    $stderr.puts("[weixin-setup] #{msg}")
-  else
-    $stderr.puts("[weixin-setup] #{msg}")
-  end
+  $stderr.puts("[weixin-setup] #{msg}")
+  wlog(msg)
 end
 
 def fail!(msg)
@@ -169,6 +173,7 @@ end
 def poll_until_confirmed(qrcode)
   deadline     = Time.now + LOGIN_DEADLINE_S
   scanned_once = false
+  started_at   = Time.now
 
   loop do
     fail!("Login timed out. Please run setup again.") if Time.now > deadline
@@ -179,7 +184,12 @@ def poll_until_confirmed(qrcode)
       timeout: QR_POLL_TIMEOUT_S
     )
 
-    next if resp.nil?  # read timeout = server-side long-poll ended, retry
+    if resp.nil?
+      wlog("poll: timeout/nil, retrying...")
+      next
+    end
+
+    wlog("poll response: #{resp.to_json}")
 
     case resp["status"]
     when "wait"
@@ -190,10 +200,19 @@ def poll_until_confirmed(qrcode)
         scanned_once = true
       end
     when "confirmed"
+      elapsed = Time.now - started_at
       token    = resp["bot_token"].to_s.strip
       base_url = resp["baseurl"].to_s.strip
       base_url = ILINK_BASE_URL if base_url.empty?
       fail!("Login confirmed but no token received") if token.empty?
+      # If confirmed arrived within 3 seconds of starting, this is almost certainly
+      # iLink returning the existing login state (account already logged in),
+      # not the result of the user scanning this QR code.
+      if elapsed < 3 && !scanned_once
+        wlog("confirmed too fast (#{elapsed.round(1)}s), treating as stale session")
+        fail!("[stale-session] QR session confirmed immediately — account already logged in. Run --fetch-qr to get a fresh QR code.")
+      end
+      wlog("confirmed after #{elapsed.round(1)}s")
       return { token: token, base_url: base_url }
     when "expired"
       fail!("QR code expired. Please run setup again.")
@@ -214,6 +233,7 @@ end
 if FETCH_QR_MODE
   $stderr.puts("[weixin-setup] Fetching QR code from iLink...")
   qr_resp = ilink_get("ilink/bot/get_bot_qrcode?bot_type=#{CGI.escape(BOT_TYPE)}")
+  wlog("fetch-qr response: #{qr_resp.to_json}")
   fail!("No qrcode in response: #{qr_resp.inspect}") unless qr_resp&.dig("qrcode")
 
   qrcode     = qr_resp["qrcode"]

data/lib/clacky/mcp/stdio_transport.rb

@@ -3,8 +3,10 @@
 require "json"
 require "open3"
 require "monitor"
+require "shellwords"
 
 require_relative "transport"
+require_relative "../utils/login_shell"
 
 module Clacky
   module Mcp
@@ -29,7 +31,10 @@ module Clacky
         opts = { unsetenv_others: false }
         opts[:chdir] = @cwd if @cwd && File.directory?(@cwd)
 
-        @stdin, @stdout, @stderr, @wait_thr = Open3.popen3(full_env, @command, *@args, opts)
+        inner = ([@command] + @args).map { |a| Shellwords.shellescape(a) }.join(" ")
+        wrapped = Clacky::Utils::LoginShell.login_shell_command(inner)
+
+        @stdin, @stdout, @stderr, @wait_thr = Open3.popen3(full_env, *wrapped, opts)
         @stdin.sync = true
 
         Thread.new do

data/lib/clacky/providers.rb

@@ -335,28 +335,26 @@ module Clacky
         "name" => "Qwen (Alibaba)",
         "base_url" => "https://dashscope.aliyuncs.com/compatible-mode/v1",
         "api" => "openai-completions",
-        "default_model" => "qwen3.6-plus",
+        "default_model" => "qwen3.7-max",
         "models" => [
+          "qwen3.7-max",
           "qwen3.6-plus",
           "qwen3.6-max",
           "qwen3.6-27b",
           "qwen3.6-flash",
           "qwen-plus-latest",
-          "qwen-vl-plus",
-          "qwen-vl-max"
         ],
         "endpoint_variants" => [
           { "label" => "Mainland China",  "label_key" => "settings.models.baseurl.variant.mainland_cn",   "base_url" => "https://dashscope.aliyuncs.com/compatible-mode/v1",     "region" => "cn"   }.freeze,
           { "label" => "Singapore",       "label_key" => "settings.models.baseurl.variant.international", "base_url" => "https://dashscope-intl.aliyuncs.com/compatible-mode/v1", "region" => "intl" }.freeze,
           { "label" => "US (Virginia)",   "label_key" => "settings.models.baseurl.variant.us",            "base_url" => "https://dashscope-us.aliyuncs.com/compatible-mode/v1",   "region" => "us"   }.freeze
         ].freeze,
-        "capabilities" => { "vision" => false }.freeze,
+        "capabilities" => { "vision" => true }.freeze,
         "model_capabilities" => {
-          "qwen3.6-27b"  => { "vision" => true }.freeze,
-          "qwen-vl-plus" => { "vision" => true }.freeze,
-          "qwen-vl-max"  => { "vision" => true }.freeze
+          "qwen3.7-max" => { "vision" => false }.freeze
         }.freeze,
         "lite_models" => {
+          "qwen3.7-max"      => "qwen3.6-flash",
           "qwen3.6-plus"     => "qwen3.6-flash",
           "qwen3.6-max"      => "qwen3.6-flash",
           "qwen3.6-27b"      => "qwen3.6-flash",

data/lib/clacky/server/browser_manager.rb

@@ -258,7 +258,19 @@ module Clacky
       # 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(*wrapped, close_others: true)
-      Thread.new { stderr_io.read rescue nil }
+      stderr_buf = String.new
+      stderr_thr = Thread.new do
+        stderr_io.each_line { |line| stderr_buf << line }
+      rescue IOError
+      end
+
+      # Give the process a moment to fail fast (e.g. command not found)
+      sleep 0.1
+      unless wait_thr.alive?
+        stderr_thr.join(1)
+        Clacky::Logger.error("[BrowserManager] MCP daemon exited immediately (exit=#{wait_thr.value.exitstatus}). stderr:\n#{stderr_buf}")
+        raise "chrome-devtools-mcp failed to start (exit=#{wait_thr.value.exitstatus}): #{stderr_buf.lines.last(5).join}"
+      end
 
       # MCP handshake
       init_msg = json_rpc("initialize", {
@@ -280,9 +292,10 @@ module Clacky
       init_resp = read_response(stdout, target_id: 1,
                                 timeout: Clacky::Tools::Browser::MCP_HANDSHAKE_TIMEOUT)
       unless init_resp
-        Clacky::Logger.error("[BrowserManager] MCP initialize handshake timed out after #{Clacky::Tools::Browser::MCP_HANDSHAKE_TIMEOUT}s")
+        stderr_thr.join(0.5)
+        Clacky::Logger.error("[BrowserManager] MCP initialize handshake timed out after #{Clacky::Tools::Browser::MCP_HANDSHAKE_TIMEOUT}s. stderr:\n#{stderr_buf}")
         Process.kill("TERM", wait_thr.pid) rescue nil
-        raise "Chrome MCP initialize handshake timed out"
+        raise "Chrome MCP initialize handshake timed out. stderr: #{stderr_buf.lines.last(5).join}"
       end
 
       Clacky::Logger.debug("[BrowserManager] MCP initialize successful, sending initialized notification...")

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

@@ -55,7 +55,10 @@ module Clacky
 
             msg_type = message["message_type"]
             Clacky::Logger.info("[feishu] msg_type=#{msg_type} content=#{message["content"].to_s[0..300]}")
-            return nil unless %w[text image file].include?(msg_type)
+            unless %w[text image file post].include?(msg_type)
+              Clacky::Logger.info("[feishu] dropping unsupported msg_type=#{msg_type}")
+              return nil
+            end
 
             content_raw = message["content"]
             return nil unless content_raw
@@ -77,6 +80,11 @@ module Clacky
               file_name = content["file_name"]
               return nil unless file_key
               file_attachments = [{ key: file_key, name: file_name.to_s }]
+            when "post"
+              parsed = parse_post_content(content)
+              text = parsed[:text]
+              image_keys = parsed[:image_keys]
+              return nil if text.empty? && image_keys.empty?
             end
 
             chat_id = message["chat_id"]
@@ -122,6 +130,43 @@ module Clacky
             # Feishu mentions are formatted as <at user_id="...">Name</at>
             text.gsub(/<at[^>]*>.*?<\/at>/, "").strip
           end
+
+          # Parse a Feishu post content body into text and image_keys.
+          # post content structure from event payloads:
+          #   {"title": "", "content": [[{tag, text, ...}, ...], ...]}
+          def parse_post_content(content)
+            rows = content["content"]
+            return { text: "", image_keys: [] } unless rows.is_a?(Array)
+
+            text_lines = []
+            image_keys = []
+
+            rows.each do |row|
+              next unless row.is_a?(Array)
+              line_parts = []
+              row.each do |element|
+                next unless element.is_a?(Hash)
+                case element["tag"]
+                when "text", "md", "code_block"
+                  part = element["text"].to_s
+                  line_parts << part unless part.empty?
+                when "a"
+                  part = element["text"].to_s
+                  part = element["href"].to_s if part.empty?
+                  line_parts << part unless part.empty?
+                when "img"
+                  key = element["image_key"].to_s
+                  image_keys << key unless key.empty?
+                when "at"
+                  # skipped — mention identity resolved via top-level mentions field
+                end
+              end
+              line = line_parts.join.strip
+              text_lines << line unless line.empty?
+            end
+
+            { text: text_lines.join("\n"), image_keys: image_keys }
+          end
         end
       end
     end

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

@@ -77,7 +77,8 @@ module Clacky
 
           def handle_raw_message(raw)
             msgtype = raw["msgtype"]
-            return unless %w[text image file].include?(msgtype)
+            Clacky::Logger.info("[wecom] msgtype=#{msgtype} raw=#{raw.to_s[0..300]}")
+            return unless %w[text image file mixed].include?(msgtype)
 
             chat_id = raw["chatid"] || raw.dig("from", "userid")
             return unless chat_id
@@ -92,18 +93,9 @@ module Clacky
               text = raw.dig("text", "content").to_s.strip
               return if text.empty?
             when "image"
-              url    = raw.dig("image", "url")
-              aeskey = raw.dig("image", "aeskey")
-              return unless url
-              result = MediaDownloader.download(url, aeskey)
-              mime = MediaDownloader.detect_mime(result[:body])
-              if result[:body].bytesize > MAX_IMAGE_BYTES
-                @ws_client.send_message(chat_id, "Image too large (#{(result[:body].bytesize / 1024.0).round(0).to_i}KB), max #{MAX_IMAGE_BYTES / 1024}KB")
-                return
-              end
-              require "base64"
-              data_url = "data:#{mime};base64,#{Base64.strict_encode64(result[:body])}"
-              files = [{ name: "image.jpg", mime_type: mime, data_url: data_url }]
+              file = download_image(raw["image"], chat_id)
+              return unless file
+              files = [file]
             when "file"
               url      = raw.dig("file", "url")
               aeskey   = raw.dig("file", "aeskey")
@@ -113,6 +105,9 @@ module Clacky
               filename = result[:filename] || filename
               saved = Clacky::Utils::FileProcessor.save(body: result[:body], filename: filename)
               files = [saved]
+            when "mixed"
+              text, files = parse_mixed(raw.dig("mixed", "msg_item") || [], chat_id)
+              return if text.empty? && files.empty?
             end
 
             event = {
@@ -138,6 +133,36 @@ module Clacky
             end
           end
 
+          private def download_image(image_data, chat_id)
+            url    = image_data&.[]("url")
+            aeskey = image_data&.[]("aeskey")
+            return nil unless url
+            result = MediaDownloader.download(url, aeskey)
+            mime = MediaDownloader.detect_mime(result[:body])
+            if result[:body].bytesize > MAX_IMAGE_BYTES
+              @ws_client.send_message(chat_id, "Image too large (#{(result[:body].bytesize / 1024.0).round(0).to_i}KB), max #{MAX_IMAGE_BYTES / 1024}KB")
+              return nil
+            end
+            require "base64"
+            data_url = "data:#{mime};base64,#{Base64.strict_encode64(result[:body])}"
+            { name: "image.jpg", mime_type: mime, data_url: data_url }
+          end
+
+          private def parse_mixed(items, chat_id)
+            text_parts = []
+            files = []
+            items.each do |item|
+              case item["msgtype"]
+              when "text"
+                text_parts << item.dig("text", "content").to_s.strip
+              when "image"
+                file = download_image(item["image"], chat_id)
+                files << file if file
+              end
+            end
+            [text_parts.join("\n").strip, files]
+          end
+
           MAX_IMAGE_BYTES = Clacky::Utils::FileProcessor::MAX_IMAGE_BYTES
         end
 

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

@@ -81,6 +81,16 @@ module Clacky
       #
       # For Weixin (iLink protocol) a context_token is required for every outbound
       # message.  This method looks up the most-recently cached token for user_id.
+
+      # Return the currently-live adapter for a given platform, or nil if none running.
+      # Thread-safe — acquires @mutex to read from @adapters.
+      # @param platform [Symbol, String]
+      # @return [Object, nil]
+      def adapter_for(platform)
+        platform = platform.to_sym
+        @mutex.synchronize { @adapters.find { |a| a.platform_id == platform } }
+      end
+
       # If no token is found the message cannot be delivered and nil is returned.
       #
       # For Feishu and WeCom the chat_id / user_id is sufficient — no token needed.
@@ -91,7 +101,7 @@ module Clacky
       # @return [Hash, nil]  adapter result hash, or nil on failure
       def send_to_user(platform, user_id, message)
         platform = platform.to_sym
-        adapter  = @mutex.synchronize { @adapters.find { |a| a.platform_id == platform } }
+        adapter  = adapter_for(platform)
 
         unless adapter
           Clacky::Logger.warn("[ChannelManager] send_to_user: no running adapter for :#{platform}")
@@ -114,7 +124,7 @@ module Clacky
       # @return [Array<String>]
       def known_users(platform)
         platform = platform.to_sym
-        adapter  = @mutex.synchronize { @adapters.find { |a| a.platform_id == platform } }
+        adapter  = adapter_for(platform)
         return [] unless adapter
 
         # Weixin adapter exposes @context_tokens whose keys are user_ids
@@ -307,7 +317,7 @@ module Clacky
           if channel_ui
             @registry.with_session(old_session_id) { |s| s[:ui]&.unsubscribe_channel(channel_ui); s.delete(:channel_ui) }
           else
-            channel_ui = ChannelUIController.new(event, adapter)
+            channel_ui = ChannelUIController.new(event, -> { adapter_for(event[:platform]) })
           end
 
           bind_key_to_session(key, session_id)
@@ -384,7 +394,7 @@ module Clacky
         # Create a long-lived ChannelUIController for this session and subscribe it
         # to the session's WebUIController. It stays for the session's full lifetime
         # so all events (agent output, errors, status) flow through web_ui → channel_ui.
-        channel_ui = ChannelUIController.new(event, adapter)
+        channel_ui = ChannelUIController.new(event, -> { adapter_for(event[:platform]) })
         @registry.with_session(session_id) do |s|
           s[:ui]&.subscribe_channel(channel_ui)
           s[:channel_ui] = channel_ui

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

@@ -22,13 +22,18 @@ module Clacky
 
       attr_reader :platform, :chat_id
 
-      def initialize(event, adapter)
-        @platform   = event[:platform]
-        @chat_id    = event[:chat_id]
-        @message_id = event[:message_id]  # original message to reply under
-        @adapter    = adapter
-        @buffer     = []
-        @mutex      = Mutex.new
+      # @param event   [Hash]          inbound IM event
+      # @param adapter_resolver [Proc]  callable returning the current live adapter for this platform.
+      #   Using a resolver (instead of caching the adapter instance) ensures that after
+      #   reload_platform replaces an adapter, in-flight sessions automatically pick up the
+      #   new one — no swap/patch needed.
+      def initialize(event, adapter_resolver)
+        @platform         = event[:platform]
+        @chat_id          = event[:chat_id]
+        @message_id       = event[:message_id]  # original message to reply under
+        @adapter_resolver = adapter_resolver
+        @buffer           = []
+        @mutex            = Mutex.new
       end
 
       # Update the reply context for the current inbound message.
@@ -185,15 +190,25 @@ module Clacky
         text = text.to_s.gsub(/<think>[\s\S]*?<\/think>\n*/i, "").strip
         return if text.empty?
 
-        @adapter.send_text(@chat_id, text, reply_to: @message_id)
+        adapter = @adapter_resolver.call
+        unless adapter
+          Clacky::Logger.warn("[ChannelUI] send_text: no live adapter for :#{@platform}")
+          return nil
+        end
+        adapter.send_text(@chat_id, text, reply_to: @message_id)
       rescue StandardError => e
         Clacky::Logger.warn("[ChannelUI] send_text failed", platform: @platform, chat_id: @chat_id, error: e)
         nil
       end
 
       def send_file(path, name = nil)
-        if @adapter.respond_to?(:send_file)
-          @adapter.send_file(@chat_id, path, name: name)
+        adapter = @adapter_resolver.call
+        unless adapter
+          Clacky::Logger.warn("[ChannelUI] send_file: no live adapter for :#{@platform}")
+          return nil
+        end
+        if adapter.respond_to?(:send_file)
+          adapter.send_file(@chat_id, path, name: name)
         else
           # Fallback for adapters that don't support file sending
           send_text("File: #{name || File.basename(path)}\n#{path}")
@@ -222,7 +237,8 @@ module Clacky
       end
 
       def flush_adapter_pending
-        @adapter.flush_pending(@chat_id) if @adapter.respond_to?(:flush_pending)
+        adapter = @adapter_resolver.call
+        adapter.flush_pending(@chat_id) if adapter&.respond_to?(:flush_pending)
       end
     end
   end