openclacky 1.2.3 → 1.2.5

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,98 @@ 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.
+          #
+          # However, when stty -echo is active (the normal case for our
+          # persistent sessions), the wrapper is never echoed — so the tail
+          # marker never appears. We detect this by checking: if we have a
+          # complete line (\n present) and it does NOT contain the wrapper
+          # fingerprint, echo was suppressed and we can start streaming
+          # immediately.
+          unless wrapper_swallowed
+            tail_marker = '"$__clacky_ec"'
+            tail_idx = stream_pending.index(tail_marker)
+            if tail_idx
+              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
+              wrapper_swallowed = true
+            elsif stream_pending.include?("\n") && !stream_pending.include?("__clacky_ec")
+              # stty -echo suppressed the wrapper echo; real output is arriving.
+              wrapper_swallowed = true
+            else
+              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
+          # Collapse runs of 3+ blank lines into a single blank line so
+          # PTY noise (cursor-positioning codes cleaned to empty lines)
+          # doesn't produce a wall of whitespace in the streaming UI.
+          cleaned = cleaned.gsub(/\n{3,}/, "\n\n")
+          cleaned = cleaned.lstrip if cleaned.match?(/\A\n+\z/)
+          on_output.call(cleaned) unless cleaned.empty? || cleaned.match?(/\A\s*\z/)
+        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 +1249,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 +1515,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/utils/scripts_manager.rb

@@ -21,7 +21,6 @@ module Clacky
         install_browser.sh
         install_system_deps.sh
         install_rails_deps.sh
-        wsl_network_doctor.ps1
       ].freeze
 
       # Copy bundled scripts to ~/.clacky/scripts/ if missing or outdated.

data/lib/clacky/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Clacky
-  VERSION = "1.2.3"
+  VERSION = "1.2.5"
 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.5
 platform: ruby
 authors:
 - windy
@@ -596,7 +596,6 @@ files:
 - scripts/install_rails_deps.sh
 - scripts/install_system_deps.sh
 - scripts/uninstall.sh
-- scripts/wsl_network_doctor.ps1
 - sig/clacky.rbs
 homepage: https://github.com/clacky-ai/openclacky
 licenses: