openclacky 1.2.3 → 1.2.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 39490977253b82c6bf0e0e7c89e3763b86dbe56a46e8c6e716774c06387bc7a7
-  data.tar.gz: 25224b037f948e7252467337a4e04051340d4bd7ff75456d7a8653acfc43e94c
+  metadata.gz: 80e1b5549b0e55760ec4e0e905eea3ab50bc9a66bd8c256e628a1afdb8531ba0
+  data.tar.gz: 54142ef66c3b74d3998214202fa73618dd9b22ebdb06586c8d6896aafcb56d9d
 SHA512:
-  metadata.gz: 9ba3260b11c8b7f37c075ebc392567f3b049246932e65e1fc12df99363f86921af28c05e5fd4d46ddb1cd796092fc11315b80ef67937c13b5e6cbb9a276cdc47
-  data.tar.gz: 8de209627490544c48f3d07f8b010cc40fe6ef51e597734b61adb7c6285d65d3a309aebebe9f9f563a681db60596b797e5a79d9eaa46c85805b37b75cca9369c
+  metadata.gz: d69d02391cc1929d26f2cfc2a260d27cb6b1f6840c254ae67f7ad358f621ba16eb2476fd5cee28308f7eaf2e0eb21d5983b49de4f84c6905863292625644641a
+  data.tar.gz: 54dbeb6d31f187edc30ea4e6030776e988cf50ee7ed44a2177a77473d00c47ae358df25dfd9bd526ea93126b94733feaca5a63048cde8657201c4c1e7cd05edd

data/CHANGELOG.md

@@ -5,6 +5,30 @@ 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

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/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

@@ -350,6 +350,9 @@ module Clacky
           { "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" => true }.freeze,
+        "model_capabilities" => {
+          "qwen3.7-max" => { "vision" => false }.freeze
+        }.freeze,
         "lite_models" => {
           "qwen3.7-max"      => "qwen3.6-flash",
           "qwen3.6-plus"     => "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

data/lib/clacky/server/http_server.rb

@@ -368,6 +368,8 @@ module Clacky
           90
         elsif path == "/api/tool/browser"
           30
+        elsif path.end_with?("/benchmark")
+          20
         else
           10
         end
@@ -1798,6 +1800,7 @@ module Clacky
 
         data["mcpServers"][name] = spec
         mcp_write_raw_config(data)
+        @mcp_registry_mutex.synchronize { @mcp_registry&.reload }
         json_response(res, 200, { ok: true, name: name, config_path: mcp_config_path })
       end
 
@@ -1821,6 +1824,7 @@ module Clacky
 
         data["mcpServers"][name] = spec
         mcp_write_raw_config(data)
+        @mcp_registry_mutex.synchronize { @mcp_registry&.reload }
         json_response(res, 200, { ok: true, name: name })
       end
 
@@ -1836,6 +1840,7 @@ module Clacky
 
         data["mcpServers"].delete(name)
         mcp_write_raw_config(data)
+        @mcp_registry_mutex.synchronize { @mcp_registry&.reload }
         json_response(res, 200, { ok: true, name: name })
       end
 
@@ -3619,8 +3624,12 @@ module Clacky
         end
 
         results = threads.map do |t|
-          t.join(per_model_timeout + 3)
-          t.value rescue { ok: false, error: "thread failed" }
+          if t.join(per_model_timeout + 3)
+            t.value rescue { ok: false, error: "thread failed" }
+          else
+            t.kill
+            { ok: false, error: "Request timed out" }
+          end
         end
 
         json_response(res, 200, { ok: true, results: results })
@@ -3641,7 +3650,8 @@ module Clacky
           model_cfg["api_key"].to_s,
           base_url:         model_cfg["base_url"].to_s,
           model:            model_name,
-          anthropic_format: model_cfg["anthropic_format"] || false
+          anthropic_format: model_cfg["anthropic_format"] || false,
+          read_timeout:     timeout_sec
         )
 
         # Override Faraday timeouts via a short-lived env var isn't ideal;

data/lib/clacky/tools/browser.rb

@@ -242,7 +242,7 @@ module Clacky
           { action: "tabs", success: true, profile: "user", output: format_tabs(pages), tabs: pages }
 
         when "snapshot"
-          raw  = mcp_call("take_snapshot")
+          raw  = mcp_call("take_snapshot", with_page({}))
           text = build_ai_snapshot(extract_snapshot(raw),
                                    interactive: opts[:interactive] || opts["interactive"],
                                    compact:     opts[:compact]     || opts["compact"],
@@ -352,7 +352,7 @@ module Clacky
             sleep(ms.to_i / 1000.0)
             return { action: "act", success: true, profile: "user", output: "Waited #{ms}ms" }
           elsif sel
-            mcp_call("wait_for", { text: [sel] })
+            mcp_call("wait_for", with_page({ text: [sel] }))
           else
             sleep(1)
           end
@@ -409,7 +409,7 @@ module Clacky
 
         call_args = { format: "png", fullPage: full_page }
         call_args[:uid] = uid if uid
-        result = mcp_call("take_screenshot", call_args)
+        result = mcp_call("take_screenshot", with_page(call_args))
 
         image_block = Array(result["content"]).find { |b| b.is_a?(Hash) && b["type"] == "image" }
 

data/lib/clacky/tools/terminal.rb

@@ -199,7 +199,7 @@ module Clacky
       # ---------------------------------------------------------------------
       def execute(command: nil, session_id: nil, input: nil, background: false,
                   cwd: nil, env: nil, timeout: nil, kill: nil, idle_ms: nil,
-                  working_dir: nil, **_ignored)
+                  working_dir: nil, on_output: nil, **_ignored)
         # Auto-tune: if the caller didn't explicitly set a timeout/idle_ms
         # AND the command is a well-known long-runner (rspec, bundle install,
         # cargo build, etc.), we stretch the budget AND disable idle-return.
@@ -226,7 +226,7 @@ module Clacky
         # Continue / poll a running session
         if session_id
           return { error: "input is required when session_id is given" } if input.nil?
-          return do_continue(session_id.to_i, input.to_s, timeout: timeout, idle_ms: idle_ms)
+          return do_continue(session_id.to_i, input.to_s, timeout: timeout, idle_ms: idle_ms, on_output: on_output)
         end
 
         # Start a new command
@@ -243,7 +243,8 @@ module Clacky
           end
 
           return do_start(command.to_s, cwd: cwd, env: env, timeout: timeout,
-                          idle_ms: idle_ms, background: background ? true : false)
+                          idle_ms: idle_ms, background: background ? true : false,
+                          on_output: on_output)
         end
 
         { error: "terminal: must provide either `command`, or `session_id`+`input`, or `session_id`+`kill: true`." }
@@ -327,7 +328,7 @@ module Clacky
       # ---------------------------------------------------------------------
       # 1) Start a new command
       # ---------------------------------------------------------------------
-      private def do_start(command, cwd:, env:, timeout:, background:, idle_ms: DEFAULT_IDLE_MS)
+      private def do_start(command, cwd:, env:, timeout:, background:, idle_ms: DEFAULT_IDLE_MS, on_output: nil)
         if cwd && !Dir.exist?(cwd.to_s)
           return { error: "cwd does not exist: #{cwd}" }
         end
@@ -345,6 +346,10 @@ module Clacky
         # that doesn't already have an explicit stdin redirect.
         safe_command = redirect_exe_stdin(safe_command)
 
+        # PowerShell 5 on Chinese Windows emits CP936/GBK by default; force
+        # UTF-8 so our PTY (which decodes as UTF-8) doesn't see ??? bytes.
+        safe_command = force_powershell_utf8(safe_command)
+
         # Background / dedicated path — never reuse the persistent shell,
         # because these commands stay running and would occupy the slot.
         if background
@@ -363,7 +368,8 @@ module Clacky
             background: true,
             persistent: false,
             original_command: command,
-            rewritten_command: safe_command
+            rewritten_command: safe_command,
+            on_output: on_output
           )
         end
 
@@ -388,14 +394,15 @@ module Clacky
           idle_ms: idle_ms,
           persistent: persistent,
           original_command: command,
-          rewritten_command: safe_command
+          rewritten_command: safe_command,
+          on_output: on_output
         )
       end
 
       # ---------------------------------------------------------------------
       # 2) Continue / poll an existing session
       # ---------------------------------------------------------------------
-      private def do_continue(session_id, input, timeout:, idle_ms: DEFAULT_IDLE_MS)
+      private def do_continue(session_id, input, timeout:, idle_ms: DEFAULT_IDLE_MS, on_output: nil)
         session = SessionManager.refresh(session_id)
         return { error: "Session ##{session_id} not found (already finished or killed)." } unless session
 
@@ -406,7 +413,7 @@ module Clacky
 
         session.mutex.synchronize { session.writer.write(normalize_input_for_pty(input.to_s)) } unless input.to_s.empty?
 
-        wait_and_package(session, timeout: timeout, idle_ms: idle_ms)
+        wait_and_package(session, timeout: timeout, idle_ms: idle_ms, on_output: on_output)
       end
 
       # `\n` is a Unix newline, not the "Enter key". Inside cooked-mode PTYs
@@ -455,10 +462,11 @@ module Clacky
       #   :timeout | session_id, state=timeout    | session_id, state=background
       private def wait_and_package(session, timeout:, idle_ms: DEFAULT_IDLE_MS,
                                    background: false, persistent: false,
-                                   original_command: nil, rewritten_command: nil)
+                                   original_command: nil, rewritten_command: nil,
+                                   on_output: nil)
         start_offset = session.read_offset
 
-        _before, code, state = read_until_marker(session, timeout: timeout, idle_ms: idle_ms)
+        _before, code, state = read_until_marker(session, timeout: timeout, idle_ms: idle_ms, on_output: on_output)
 
         new_offset = log_size(session)
         raw = read_log_slice(session.log_file, start_offset, new_offset)
@@ -1066,10 +1074,16 @@ module Clacky
       #     whole persistent shell.
       def source_rc_in_session(session, rc_files)
         return if rc_files.empty?
-        cmd = rc_files.map { |f|
+        sources = rc_files.map { |f|
           escaped = f.gsub('"', '\"')
           "source \"#{escaped}\" || true"
         }.join("; ")
+        # rc files often gate interactive-only setup (mise activate, direnv
+        # hook, nvm, pyenv, oh-my-zsh) on `[ -z "$PS1" ]` / `[[ -o interactive ]]`.
+        # We normally keep PS1="" to suppress prompt noise in captured output,
+        # but that makes those gates fail when we re-source rc here. Set a
+        # placeholder PS1 just for the duration of the source, then restore "".
+        cmd = %Q{__clacky_old_ps1="$PS1"; PS1="__CLACKY_PS1__"; #{sources}; PS1="$__clacky_old_ps1"; unset __clacky_old_ps1}
         run_inline(session, cmd, timeout: 15)
       end
 
@@ -1122,7 +1136,12 @@ module Clacky
       # Poll the log file until a marker matches, idle-return fires, or timeout.
       # Returns [raw_before_marker, exit_code_or_nil, state].
       # state ∈ :matched, :idle, :timeout, :eof
-      private def read_until_marker(session, timeout:, idle_ms: DEFAULT_IDLE_MS)
+      #
+      # `on_output` (optional Proc): called as on_output.call(chunk_string) for
+      # each new piece of output as it arrives, BEFORE the marker is detected.
+      # The chunk has ANSI codes / wrapper echoes stripped so it's safe to
+      # render in a UI. The completion marker itself is never passed through.
+      private def read_until_marker(session, timeout:, idle_ms: DEFAULT_IDLE_MS, on_output: nil)
         return ["", nil, :eof] unless session.marker_regex
 
         deadline    = Time.now + timeout
@@ -1130,14 +1149,87 @@ module Clacky
         start_size  = session.read_offset
         last_size   = start_size
         last_change = Time.now
+        streamed_to = start_size  # bytes already pushed to on_output
+        # Per-call streaming state: we hold back bytes until we see a \n so
+        # we can run cleaning on whole lines, then drop wrapper-echo lines.
+        stream_pending = +""
+        # Phase: until we observe the full `{ user_cmd; }; __clacky_ec=$?; printf "..." "$__clacky_ec"`
+        # wrapper echo (or decide it never came), buffer everything so the
+        # wrapper opener `{ ...` doesn't leak to the UI.
+        wrapper_swallowed = false
+
+        flush_stream = lambda do |raw, force_partial: false|
+          return unless on_output && raw && !raw.empty?
+          stream_pending << raw
+
+          # Phase 1: swallow the wrapper echo. The wrapper always ends with
+          # the literal printf tail `"$__clacky_ec"`. Until we see that, we
+          # accumulate; once we do, we strip the whole wrapper out and only
+          # emit whatever real output came after it.
+          unless wrapper_swallowed
+            tail_marker = '"$__clacky_ec"'
+            tail_idx = stream_pending.index(tail_marker)
+            if tail_idx
+              # Strip from start through end-of-line of the printf tail.
+              eol_after = stream_pending.index("\n", tail_idx) || (stream_pending.bytesize - 1)
+              stream_pending.replace(stream_pending.byteslice(eol_after + 1, stream_pending.bytesize - eol_after - 1).to_s)
+              wrapper_swallowed = true
+            elsif force_partial
+              # End of stream and we never saw the wrapper tail — give up
+              # on swallowing and emit what we have, run normal stripping.
+              wrapper_swallowed = true
+            else
+              # Still hunting; keep buffering. Emit nothing yet.
+              return
+            end
+          end
+
+          if force_partial
+            buffered = stream_pending.dup
+            stream_pending.clear
+          else
+            nl = stream_pending.rindex("\n")
+            return if nl.nil?
+            buffered = stream_pending.byteslice(0, nl + 1)
+            stream_pending.replace(stream_pending.byteslice(nl + 1, stream_pending.bytesize - nl - 1).to_s)
+          end
+          cleaned = OutputCleaner.clean(buffered)
+          # Strip any wrapper echo that still slipped through (e.g. when a
+          # session is reused and ZLE re-echoes our wrapper mid-stream).
+          cleaned = strip_command_echo(cleaned, marker_token: session.marker_token)
+          # Belt-and-braces: drop any line that still carries our internal
+          # tokens.
+          cleaned = cleaned.lines.reject do |ln|
+            ln.include?("__clacky_ec") ||
+              ln.include?("__CLACKY_DONE_") ||
+              ln.include?("__clacky_f") ||
+              ln.include?("__clacky_pc") ||
+              ln.match?(/\A\s*\}\s*>\s*\/dev\/null\s+2>&1;?\s*\z/)
+          end.join
+          on_output.call(cleaned) unless cleaned.empty?
+        rescue StandardError
+          # Streaming is best-effort — never let a UI bug abort the command.
+        end
 
         loop do
           current_size = log_size(session)
           if current_size > last_size
             slice = read_log_slice(session.log_file, session.read_offset, current_size)
             if (m = slice.match(session.marker_regex))
+              marker_abs = session.read_offset + m.begin(0)
+              if marker_abs > streamed_to
+                tail = read_log_slice(session.log_file, streamed_to, marker_abs)
+                flush_stream.call(tail, force_partial: true)
+              end
               return [slice[0...m.begin(0)], m[1].to_i, :matched]
             end
+
+            if current_size > streamed_to
+              new_chunk = read_log_slice(session.log_file, streamed_to, current_size)
+              flush_stream.call(new_chunk)
+              streamed_to = current_size
+            end
+
             last_size = current_size
             last_change = Time.now
           end
@@ -1146,16 +1238,31 @@ module Clacky
           if session.status == "exited" || session.status == "killed"
             slice = read_log_slice(session.log_file, session.read_offset, log_size(session))
             if (m = slice.match(session.marker_regex))
+              marker_abs = session.read_offset + m.begin(0)
+              if marker_abs > streamed_to
+                tail = read_log_slice(session.log_file, streamed_to, marker_abs)
+                flush_stream.call(tail, force_partial: true)
+              end
               return [slice[0...m.begin(0)], m[1].to_i, :matched]
             end
+            final_size = log_size(session)
+            if final_size > streamed_to
+              flush_stream.call(read_log_slice(session.log_file, streamed_to, final_size), force_partial: true)
+            end
             return [slice, nil, :eof]
           end
 
           if last_size > start_size && (Time.now - last_change) >= idle_sec
+            # Going idle: flush any partial buffered line (e.g. an in-progress
+            # progress bar without trailing \n) so the UI sees current state.
+            flush_stream.call("", force_partial: true) unless stream_pending.empty?
             return ["", nil, :idle]
           end
 
-          return ["", nil, :timeout] if Time.now >= deadline
+          if Time.now >= deadline
+            flush_stream.call("", force_partial: true) unless stream_pending.empty?
+            return ["", nil, :timeout]
+          end
           sleep 0.05
         end
       end
@@ -1397,7 +1504,55 @@ module Clacky
       private def redirect_exe_stdin(command)
         return command unless command =~ /\.exe\b/i
         return command if command =~ /<\s*[^\s|&;]/
-        "#{command} </dev/null"
+
+        # If the command has a shell-level pipe, insert </dev/null before
+        # the first pipe so only the .exe segment gets its stdin redirected,
+        # rather than starving a downstream pipe reader (e.g. `tr`, `grep`).
+        if command =~ /\|/
+          command.sub(/\s*\|/, ' </dev/null |')
+        else
+          "#{command} </dev/null"
+        end
+      end
+
+      # PowerShell 5 on Chinese Windows defaults [Console]::OutputEncoding
+      # to CP936/GBK; our PTY decodes as UTF-8 so non-ASCII output becomes
+      # `???`. Inject UTF-8 setup into the user's PowerShell command so the
+      # shell emits UTF-8 bytes regardless of host locale.
+      POWERSHELL_PREAMBLE =
+        "[Console]::OutputEncoding=[Text.Encoding]::UTF8;" \
+        "$OutputEncoding=[Text.Encoding]::UTF8;"
+
+      # Only rewrites simple `powershell[.exe]` / `pwsh[.exe]` invocations.
+      # Skips -File / -EncodedCommand / commands already handling encoding /
+      # pipelines (anything risky to splice).
+      private def force_powershell_utf8(command)
+        cmd = command.to_s
+        return command unless cmd =~ /\A\s*(?:powershell(?:\.exe)?|pwsh(?:\.exe)?)\b/i
+        return command if cmd =~ /OutputEncoding/i
+        return command if cmd =~ /\s-(?:File|EncodedCommand|enc|f)\b/i
+
+        # `-Command "..."` form: pipeline / chain characters inside the
+        # quoted body are PowerShell-internal, not shell-level, so we splice
+        # safely into the quoted string.
+        if (m = cmd.match(/\A(\s*(?:powershell(?:\.exe)?|pwsh(?:\.exe)?)\s+(?:[^"'\s]+\s+)*?-(?:Command|c)\s+)(["'])(.*)\2(\s*(?:<\s*\S+\s*)?)\z/i))
+          head, quote, body, tail = m[1], m[2], m[3], m[4].to_s
+          return "#{head}#{quote}#{POWERSHELL_PREAMBLE}#{body}#{quote}#{tail}"
+        end
+
+        # Outside the quoted-Command form, refuse to splice if there's any
+        # shell-level pipe / chain — too risky to get the boundaries right.
+        return command if cmd =~ /[|&;]/
+
+        if (m = cmd.match(/\A(\s*(?:powershell(?:\.exe)?|pwsh(?:\.exe)?))(.*)\z/i))
+          exe, rest = m[1], m[2].to_s.strip
+          return command if rest.start_with?("-") && rest !~ /\A-(?:Command|c)\b/i
+          rest = rest.sub(/\A-(?:Command|c)\b\s*/i, "")
+          inner = rest.empty? ? POWERSHELL_PREAMBLE.chomp(";") : "#{POWERSHELL_PREAMBLE}#{rest}"
+          return %Q{#{exe} -Command "#{inner}"}
+        end
+
+        command
       end
     end
   end

data/lib/clacky/ui2/ui_controller.rb

@@ -442,6 +442,7 @@ module Clacky
         # doesn't bleed into the next one, and so the buffer is ready before
         # on_output starts firing (which can happen before show_progress is called).
         @stdout_lines = nil
+        @stdout_partial_tail = false
 
         # Special handling for request_user_feedback: render as a readable interactive card
         # with the full question and options, rather than the truncated format_call summary.
@@ -493,11 +494,27 @@ module Clacky
       # Receive a chunk of shell stdout from the on_output callback.
       # Lines are buffered into @stdout_lines so that Ctrl+O can open a
       # fullscreen live view, matching the original output_buffer interaction.
-      # @param lines [Array<String>] One or more stdout chunks
+      # @param lines [Array<String>] One or more stdout chunks (may contain
+      #   embedded newlines or be partial lines)
       def show_tool_stdout(lines)
         return if lines.nil? || lines.empty?
         @stdout_lines ||= []
-        @stdout_lines.concat(lines.map(&:chomp))
+        # Chunks may carry multiple newlines or trailing partial lines.
+        # Re-split on \n so the fullscreen view renders one logical line per row.
+        lines.each do |chunk|
+          next if chunk.nil? || chunk.empty?
+          chunk.to_s.split("\n", -1).each_with_index do |part, idx|
+            if idx == 0 && !@stdout_lines.empty? && @stdout_partial_tail
+              @stdout_lines[-1] = @stdout_lines[-1] + part
+            else
+              @stdout_lines << part
+            end
+          end
+          # Track whether the chunk ended on a partial line (no trailing \n)
+          # so the next chunk's first segment appends to it instead of
+          # starting a new row.
+          @stdout_partial_tail = !chunk.to_s.end_with?("\n")
+        end
       end
 
       # Show completion status (only for tasks with more than 5 iterations)
@@ -1354,6 +1371,7 @@ module Clacky
         # Also clear stdout buffer used by Ctrl+O (unrelated to progress, but
         # we don't want stale command output carried across user turns).
         @stdout_lines = nil
+        @stdout_partial_tail = false
 
         # Render user message immediately before running agent
         unless data[:text].empty? && data[:files].empty?

data/lib/clacky/utils/login_shell.rb

@@ -51,7 +51,9 @@ module Clacky
 
         # { rc_sources; } 1>&2 — send rc-time stdout to stderr so target's
         # stdout is pristine. `exec` replaces the shell with target.
-        script = "{ #{rc_sources}; } 1>&2; exec #{command}"
+        # PS1 trick: Ubuntu .bashrc has `[ -z "$PS1" ] && return` guard that
+        # skips the entire file in non-interactive shells. Setting PS1 defeats it.
+        script = "PS1='$ '; { #{rc_sources}; } 1>&2; exec #{command}"
         [shell, "-c", script]
       end
 

data/lib/clacky/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Clacky
-  VERSION = "1.2.3"
+  VERSION = "1.2.4"
 end

data/lib/clacky/web/app.css

@@ -3649,6 +3649,7 @@ body {
 .model-card-grid-actions {
   display: flex;
   flex-direction: row;
+  flex-wrap: wrap;
   gap: 0.5rem;
   padding-top: 0.625rem;
   border-top: 1px solid var(--color-border-primary);

data/lib/clacky/web/settings.js

@@ -169,6 +169,11 @@ const Settings = (() => {
       providerValue.classList.add("placeholder");
     }
 
+    // Reset save button
+    const saveBtn = document.getElementById("model-modal-save");
+    saveBtn.textContent = I18n.t("settings.models.btn.save");
+    saveBtn.disabled = false;
+
     // Clear test result
     document.getElementById("model-modal-test-result").textContent = "";
     document.getElementById("model-modal-test-result").className = "model-test-result";

data/lib/clacky/web/weixin-qr.html

@@ -140,10 +140,11 @@
   <script>
     const params  = new URLSearchParams(location.search);
     const url     = params.get("url");
-    // since: Unix timestamp (seconds) passed by the setup skill when opening this page.
-    // We only show success if token_updated_at > since, preventing false positives
-    // when the user already had a token from a previous login.
-    const since   = parseInt(params.get("since") || "0", 10);
+    // since: the moment this page loaded, in Unix seconds.
+    // We only show success if token_updated_at >= since, so a pre-existing token
+    // never triggers the overlay.
+    // Intentionally NOT taken from the URL param — the page is the source of truth.
+    const since   = Math.floor(Date.now() / 1000);
     const el      = document.getElementById("qrcode");
 
     if (!url) {

data/scripts/install.ps1

@@ -11,8 +11,8 @@
 #     -BrandName    Display name shown in prompts    (default: OpenClacky)
 #     -CommandName  CLI command name after install   (default: openclacky)
 #
-# WSL2 is preferred. If virtualisation is unavailable (e.g. running inside a VM),
-# the script automatically falls back to WSL1.
+# WSL1 is preferred (shares Windows network stack — no mirrored networking needed).
+# If WSL1 import fails, the script falls back to WSL2 with mirrored networking.
 # If WSL is not installed at all, the script enables it and asks you to reboot.
 # After rebooting, run the same command again to complete installation.
 #
@@ -501,32 +501,59 @@ if ($installPhase -eq "wsl-pending" -and $wslCode -eq 1) {
 # wslCode != 1 (0, -1, -444, 50, etc.): WSL is functional, continue.
 Remove-InstallReg -Name "InstallPhase"
 
-# Step 2: Install Ubuntu, preferring WSL2 when the real rootfs imports cleanly.
+# Step 2: Install Ubuntu, preferring WSL1 (shares Windows network — no mirrored needed).
+# If WSL1 import fails, fall back to WSL2.
+# If the distro already exists, keep whatever version was previously installed.
 if (Test-UbuntuInstalled) {
     Write-Info "Ubuntu (WSL) already installed — skipping import."
     $wslVersion = Get-InstallReg -Name "WslVersion" -Default 2
 } else {
     $tarPath = Get-UbuntuRootfs
-    if (Test-VirtualisationSupported -TarPath $tarPath) {
-        wsl.exe --set-default-version 2 >$null 2>$null
-        Install-UbuntuRootfs -WslVersion 2 -TarPath $tarPath
-        $wslVersion = 2
+
+    # Try WSL1 first
+    Write-Info "Attempting WSL1 import..."
+    $wsl1Ok = $false
+    try {
+        New-Item -ItemType Directory -Force -Path $UBUNTU_WSL_DIR | Out-Null
+        wsl.exe --import Ubuntu $UBUNTU_WSL_DIR $tarPath --version 1 >$null 2>$null
+        $wsl1Ok = ($LASTEXITCODE -eq 0)
+    } catch {
+        $wsl1Ok = $false
+    }
+
+    if ($wsl1Ok) {
+        Write-Success "Ubuntu (WSL1) imported successfully."
+        $wslVersion = 1
     } else {
-        if ($wslFeaturesEnabled -ne "1") {
-            # WSL components were never fully prepared — run Enable-WslFeatures and reboot.
-            Write-Warn "WSL2 is not available and WSL components have not been fully set up."
-            Enable-WslFeatures
-            # Always exits (prompts reboot)
+        # Clean up failed WSL1 attempt
+        wsl.exe --unregister Ubuntu 2>$null | Out-Null
+        Remove-Item -Force -Recurse -ErrorAction SilentlyContinue $UBUNTU_WSL_DIR
+
+        Write-Info "WSL1 import failed, trying WSL2..."
+        if (Test-VirtualisationSupported -TarPath $tarPath) {
+            wsl.exe --set-default-version 2 >$null 2>$null
+            Install-UbuntuRootfs -WslVersion 2 -TarPath $tarPath
+            $wslVersion = 2
+        } else {
+            if ($wslFeaturesEnabled -ne "1") {
+                Write-Warn "Neither WSL1 nor WSL2 is available. Enabling WSL components..."
+                Enable-WslFeatures
+                # Always exits (prompts reboot)
+            }
+            Write-Fail "Failed to import Ubuntu into both WSL1 and WSL2."
+            Write-Fail "Please ensure Windows Subsystem for Linux is enabled and try again."
+            exit 1
         }
-        Write-Info "[main] WSL2 unavailable, falling back to WSL1..."
-        Install-UbuntuRootfs -WslVersion 1 -TarPath $tarPath
-        $wslVersion = 1
     }
 }
 
-if ($wslVersion -eq 2) { Set-Wsl2MirroredNetworking }
-
 Write-Success "WSL is ready."
 Run-InstallInWsl
+
+# For WSL2, configure mirrored networking AFTER install.sh succeeds (NAT is more
+# reliable for outbound traffic during installation). The shutdown here is safe
+# because installation is already complete.
+if ($wslVersion -eq 2) { Set-Wsl2MirroredNetworking }
+
 Set-InstallReg -Name "WslVersion" -Value $wslVersion
 Show-PostInstall -WslVersion $wslVersion

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: openclacky
 version: !ruby/object:Gem::Version
-  version: 1.2.3
+  version: 1.2.4
 platform: ruby
 authors:
 - windy