openclacky 1.2.4 → 1.2.6

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

@@ -111,96 +111,6 @@ 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:
@@ -278,6 +188,12 @@ If still failing:
 >
 > Run `/browser-setup doctor` to diagnose the issue in detail.
 
+Fetch the online troubleshooting guide for additional help:
+
+```
+web_fetch(url="https://www.openclacky.com/docs/browser-troubleshooting")
+```
+
 Stop here and suggest running doctor.
 
 #### Case B: Other errors (MCP handshake timeout, daemon crash, etc.)
@@ -514,3 +430,13 @@ After fixing these issues, run `/browser-setup` again to verify.
 
 The browser tool is ready to use.
 ```
+
+### Online Troubleshooting Guide
+
+If any ❌ items are found, or the user reports a problem you cannot resolve with the above scenarios, fetch the latest troubleshooting guide:
+
+```
+web_fetch(url="https://www.openclacky.com/docs/browser-troubleshooting")
+```
+
+Use the content from that page to provide up-to-date diagnosis and resolution steps. This online document is maintained separately and may contain newer solutions not listed here.

data/lib/clacky/message_format/anthropic.rb

@@ -39,6 +39,17 @@ module Clacky
         msg[:content].select { |b| b[:type] == "tool_result" }.map { |b| b[:tool_use_id] }
       end
 
+      # Anthropic requires tool_use.id to match ^[a-zA-Z0-9_-]+$ (max 128 chars).
+      # Some OpenAI-compatible upstreams (e.g. kimi-k2.6) return ids like "tool_name:0"
+      # — fine for OpenAI, rejected by Anthropic. We replace illegal chars with "_"
+      # at the format boundary so ids stay self-consistent across use/result pairs
+      # (pure function → same input maps to same output in both directions).
+      def sanitize_tool_use_id(id)
+        s = id.to_s
+        s = s.gsub(/[^a-zA-Z0-9_-]/, "_")
+        s.length > 128 ? s[0, 128] : s
+      end
+
       # ── Request building ──────────────────────────────────────────────────────
 
       # Convert canonical @messages + tools into an Anthropic API request body.
@@ -156,7 +167,6 @@ module Clacky
       end
 
       # ── Tool result formatting ────────────────────────────────────────────────
-
       # Format tool results into canonical messages to append to @messages.
       # Input:  response (canonical, has :tool_calls), tool_results array
       # Output: canonical messages: [{ role: "tool", tool_call_id:, content: }]
@@ -211,7 +221,7 @@ module Clacky
               else
                 raw_args
               end
-            blocks << { type: "tool_use", id: tc[:id], name: name, input: input || {} }
+            blocks << { type: "tool_use", id: sanitize_tool_use_id(tc[:id]), name: name, input: input || {} }
           end
 
           return { role: "assistant", content: blocks }
@@ -250,7 +260,7 @@ module Clacky
                          else
                            raw_content
                          end
-          block = { type: "tool_result", tool_use_id: msg[:tool_call_id], content: tool_content }
+          block = { type: "tool_result", tool_use_id: sanitize_tool_use_id(msg[:tool_call_id]), content: tool_content }
           block[:cache_control] = hoisted_cache_control if hoisted_cache_control
           return { role: "user", content: [block] }
         end

data/lib/clacky/message_format/bedrock.rb

@@ -187,7 +187,7 @@ module Clacky
             name  = func[:name]  || tc[:name]
             raw_args = func[:arguments] || tc[:arguments]
             input = raw_args.is_a?(String) ? (JSON.parse(raw_args) rescue {}) : (raw_args || {})
-            blocks << { toolUse: { toolUseId: tc[:id], name: name, input: input } }
+            blocks << { toolUse: { toolUseId: Anthropic.sanitize_tool_use_id(tc[:id]), name: name, input: input } }
           end
 
           return { role: "assistant", content: blocks }
@@ -208,7 +208,7 @@ module Clacky
                          end
           return {
             role: "user",
-            content: [{ toolResult: { toolUseId: msg[:tool_call_id], content: result_blocks } }]
+            content: [{ toolResult: { toolUseId: Anthropic.sanitize_tool_use_id(msg[:tool_call_id]), content: result_blocks } }]
           }
         end
 

data/lib/clacky/platform_http_client.rb

@@ -228,12 +228,17 @@ module Clacky
           h.request(req) do |resp|
             case resp.code.to_i
             when 200
+              expected_len = resp["content-length"]&.to_i
               File.open(dest, "wb") do |f|
                 resp.read_body do |chunk|
                   f.write(chunk)
                   written += chunk.bytesize
                 end
               end
+              if expected_len && expected_len > 0 && written != expected_len
+                raise RetryableNetworkError,
+                      "Truncated download: got #{written} bytes, expected #{expected_len}"
+              end
             when 301, 302, 303, 307, 308
               location = resp["location"]
               raise RetryableNetworkError, "Redirect with no Location header" if location.nil? || location.empty?
@@ -354,13 +359,35 @@ module Clacky
         { success: true, data: body["data"] || body }
       else
         error_code = body["code"]
+        server_msg = extract_server_error_message(body)
         error_msg  = API_ERROR_MESSAGES[error_code] ||
-                     body["error"] ||
+                     server_msg ||
                      "Request failed (HTTP #{code}#{error_code ? ", code: #{error_code}" : ""}). Please contact support."
         { success: false, error: error_msg, data: body }
       end
     end
 
+    # Server error messages can come back under different keys / shapes:
+    #   { "error":  "msg" }           — single string
+    #   { "errors": ["msg1", "msg2"] } — array of strings (Rails .errors.full_messages)
+    #   { "errors": "msg" }            — string (less common)
+    #   { "message": "msg" }           — alternative key
+    # Returns the first non-blank human-readable string, or nil if none.
+    private def extract_server_error_message(body)
+      return nil unless body.is_a?(Hash)
+
+      [body["error"], body["errors"], body["message"]].each do |val|
+        case val
+        when String
+          return val unless val.strip.empty?
+        when Array
+          joined = val.compact.map(&:to_s).reject(&:empty?).join("; ")
+          return joined unless joined.empty?
+        end
+      end
+      nil
+    end
+
     # Raised for transient failures that should be retried (timeouts, conn resets, SSL errors).
     class RetryableNetworkError < StandardError; end
   end

data/lib/clacky/providers.rb

@@ -237,33 +237,6 @@ module Clacky
         "website_url" => "https://console.anthropic.com/settings/keys"
       }.freeze,
 
-      "clackyai-sea" => {
-        "name" => "ClackyAI(Sea)",
-        "base_url" => "https://api.clacky.ai",
-        "api" => "bedrock",
-        "default_model" => "abs-claude-sonnet-4-5",
-        "models" => [
-          "abs-claude-opus-4-6",
-          "abs-claude-sonnet-4-6",
-          "abs-claude-sonnet-4-5",
-          "abs-claude-haiku-4-5"
-        ],
-        # Claude family — all vision-capable.
-        "capabilities" => { "vision" => true }.freeze,
-        # Per-primary lite pairing — see openclacky preset for rationale.
-        "lite_models" => {
-          "abs-claude-opus-4-6"   => "abs-claude-haiku-4-5",
-          "abs-claude-sonnet-4-6" => "abs-claude-haiku-4-5",
-          "abs-claude-sonnet-4-5" => "abs-claude-haiku-4-5"
-        },
-        # Fallback chain: if a model is unavailable, try the next one in order.
-        # Keys are primary model names; values are the fallback model to use instead.
-        "fallback_models" => {
-          "abs-claude-sonnet-4-6" => "abs-claude-sonnet-4-5"
-        },
-        "website_url" => "https://clacky.ai"
-      }.freeze,
-
       "mimo" => {
         "name" => "MiMo (Xiaomi)",
         "base_url" => "https://api.xiaomimimo.com/v1",

data/lib/clacky/server/http_server.rb

@@ -436,6 +436,7 @@ module Clacky
         when ["GET",    "/api/billing/summary"]   then api_billing_summary(req, res)
         when ["GET",    "/api/billing/daily"]     then api_billing_daily(req, res)
         when ["GET",    "/api/billing/records"]   then api_billing_records(req, res)
+        when ["DELETE", "/api/billing/clear"]     then api_billing_clear(req, res)
         when ["PATCH",  "/api/sessions/:id/model"] then api_switch_session_model(req, res)
         when ["PATCH",  "/api/sessions/:id/working_dir"] then api_change_session_working_dir(req, res)
         else
@@ -1113,30 +1114,32 @@ module Clacky
 
       # GET /api/billing/summary
       # Returns billing summary for a time period
-      # Query params: period (day|week|month|year|all, default: month)
+      # Query params: period (day|week|month|year|all, default: month), model (optional)
       def api_billing_summary(req, res)
         require_relative "../billing/billing_store"
 
         query  = URI.decode_www_form(req.query_string.to_s).to_h
         period = (query["period"] || "month").to_sym
+        model  = query["model"]
 
         store   = Clacky::Billing::BillingStore.new
-        summary = store.summary(period: period)
+        summary = store.summary(period: period, model: model)
 
         json_response(res, 200, summary)
       end
 
       # GET /api/billing/daily
       # Returns daily cost breakdown
-      # Query params: days (default: 30)
+      # Query params: days (default: 30), model (optional)
       def api_billing_daily(req, res)
         require_relative "../billing/billing_store"
 
         query = URI.decode_www_form(req.query_string.to_s).to_h
         days  = [(query["days"] || "30").to_i, 90].min
+        model = query["model"]
 
         store = Clacky::Billing::BillingStore.new
-        daily = store.daily_breakdown(days: days)
+        daily = store.daily_breakdown(days: days, model: model)
 
         json_response(res, 200, { days: daily })
       end
@@ -1161,6 +1164,23 @@ module Clacky
         })
       end
 
+      # DELETE /api/billing/clear
+      # Clears billing records
+      # Query params: scope (today|all, default: today)
+      def api_billing_clear(req, res)
+        require_relative "../billing/billing_store"
+
+        query = URI.decode_www_form(req.query_string.to_s).to_h
+        scope = query["scope"] || "today"
+
+        store = Clacky::Billing::BillingStore.new
+        deleted = store.clear(scope: scope.to_sym)
+
+        json_response(res, 200, { ok: true, deleted: deleted, scope: scope })
+      rescue => e
+        json_response(res, 500, { error: e.message })
+      end
+
       # GET /api/version
       # Returns current version and latest version from RubyGems (cached for 1 hour).
       def api_get_version(res)

data/lib/clacky/tools/browser.rb

@@ -35,7 +35,7 @@ module Clacky
         Workflow: open → snapshot(interactive:true) → act(ref=...). New tab from `open` is auto-selected; only use `focus` to switch back to a previously-opened tab.
         snapshot: returns hierarchical a11y tree truncated to ~8KB. Use query="text" to seek, or offset=N to page.
         act kinds: click | dblclick | type | fill | press | hover | scroll | drag | select | wait | evaluate | click_at
-        evaluate: `js` is a function body, e.g. `return document.title` or `const x=...; return x;` — result is JSON-encoded.
+        evaluate: `js` is a JS expression, e.g. "document.title". For multi-line / async logic use an IIFE: "(async () => { const r = await fetch(...); return r.status })()". Result is JSON-encoded.
         screenshot: expensive — pass `ref` to capture one element instead of the whole page.
       DESC
       self.tool_category = "web"
@@ -58,7 +58,7 @@ module Clacky
           amount:      { type: "integer", description: "act scroll pixels (default 300)" },
           ms:          { type: "integer", description: "act wait ms" },
           selector:    { type: "string",  description: "act wait: text or CSS selector" },
-          js:          { type: "string",  description: "act evaluate: JS function body (use return)" },
+          js:          { type: "string",  description: "act evaluate: JS expression (use IIFE for multi-line/async)" },
           target_ref:  { type: "string",  description: "act drag destination ref" },
           values:      { type: "array",   items: { type: "string" }, description: "act select options" },
           x:           { type: "number",  description: "click_at x px" },
@@ -264,7 +264,7 @@ module Clacky
           url = require_url(opts)
           return url if url.is_a?(Hash)
           invalidate_page_cache!
-          mcp_call("navigate_page", { type: "url", url: url })
+          mcp_call("navigate_page", with_page({ type: "url", url: url }))
           wait_for_page_ready
           { action: "navigate", success: true, profile: "user", url: url, output: "Navigated to: #{url}" }
 
@@ -385,19 +385,10 @@ module Clacky
         pid ? args.merge(pageId: pid) : args
       end
 
-      # Wrap user-supplied JS as a Chrome-DevTools-MCP `function` argument.
-      # We treat `js` as a function body so users can write `const x = ...; return x;`
-      # naturally. For pure expressions ("document.title"), we auto-prepend `return`
-      # so the result still flows back. Detection is conservative — the presence of
-      # `return` or any top-level statement keyword skips the auto-return.
       private def build_evaluate_function(js)
         body = js.to_s.strip
         return "() => {}" if body.empty?
-
-        looks_like_statement = body.match?(/(^|[\s;{])(return|const|let|var|if|for|while|throw|try|switch|function|class|do|await|async)\b/) ||
-                               body.include?(";")
-        body = "return (#{body})" unless looks_like_statement
-        "() => { #{body} }"
+        "() => (#{body})"
       end
 
       SCREENSHOT_MAX_WIDTH        = 800

data/lib/clacky/tools/terminal.rb

@@ -1166,20 +1166,26 @@ module Clacky
           # 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
-              # 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
+            elsif stream_pending.include?("\n") && !stream_pending.include?("__clacky_ec")
+              # stty -echo suppressed the wrapper echo; real output is arriving.
               wrapper_swallowed = true
             else
-              # Still hunting; keep buffering. Emit nothing yet.
               return
             end
           end
@@ -1206,7 +1212,12 @@ module Clacky
               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?
+          # 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
@@ -1502,6 +1513,7 @@ module Clacky
       # Detect .exe invocations and redirect stdin from /dev/null unless
       # the command already has an explicit stdin redirect.
       private def redirect_exe_stdin(command)
+        return command unless Clacky::Utils::EnvironmentDetector.wsl?
         return command unless command =~ /\.exe\b/i
         return command if command =~ /<\s*[^\s|&;]/
 
@@ -1520,8 +1532,7 @@ module Clacky
       # `???`. 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;"
+        "[Console]::OutputEncoding=[Text.Encoding]::UTF8;"
 
       # Only rewrites simple `powershell[.exe]` / `pwsh[.exe]` invocations.
       # Skips -File / -EncodedCommand / commands already handling encoding /

data/lib/clacky/utils/file_processor.rb

@@ -43,10 +43,12 @@ module Clacky
       .mp3 .mp4 .avi .mov .mkv .wav .flac
       .ttf .otf .woff .woff2
       .db .sqlite .bin .dat
+      .wps .et .dps
     ].freeze
 
     GLOB_ALLOWED_BINARY_EXTENSIONS = %w[
       .pdf .doc .docx .ppt .pptx .xls .xlsx .odt .odp .ods
+      .wps .et .dps
     ].freeze
 
     LLM_BINARY_EXTENSIONS = %w[.png .jpg .jpeg .gif .webp .pdf].freeze
@@ -64,6 +66,7 @@ module Clacky
       ".docx" => :document,  ".doc"  => :document,
       ".xlsx" => :spreadsheet, ".xls" => :spreadsheet,
       ".pptx" => :presentation, ".ppt" => :presentation,
+      ".wps"  => :document, ".et"  => :spreadsheet, ".dps" => :presentation,
       ".pdf"  => :pdf,
       ".zip"  => :zip, ".gz" => :zip, ".tgz" => :zip, ".tar" => :zip, ".rar" => :zip, ".7z" => :zip,
       ".png"  => :image, ".jpg" => :image, ".jpeg" => :image,

data/lib/clacky/utils/parser_manager.rb

@@ -30,6 +30,9 @@ module Clacky
         ".xls"  => "xlsx_parser.rb",
         ".pptx" => "pptx_parser.rb",
         ".ppt"  => "pptx_parser.rb",
+        ".wps"  => "wps_parser.rb",
+        ".et"   => "wps_parser.rb",
+        ".dps"  => "wps_parser.rb",
       }.freeze
 
       # Ensure ~/.clacky/parsers/ exists and all default parsers are present.

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.4"
+  VERSION = "1.2.6"
 end